Java-gRPC-Python开发环境安装配置

# python -m pip install grpcio
# python -m pip install grpcio-tools

(base) [root@VM-4-12-centos notebook]# python -m pip install grpcio-tools
Looking in indexes: http://mirrors.tencentyun.com/pypi/simple
Collecting grpcio-tools
  Downloading http://mirrors.tencentyun.com/pypi/packages/3a/51/aeb8418cb5e336aa8df2e6ea55bdab3e041b39a8aa2850df81fcc279aaf5/grpcio_tools-1.51.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.4 MB)
     |████████████████████████████████| 2.4 MB 459 kB/s 
Collecting grpcio>=1.51.1
  Downloading http://mirrors.tencentyun.com/pypi/packages/fc/62/bccba142a6ad670727fb329579d18ab44e8b3585b23068baa0b7196b86b6/grpcio-1.51.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (4.8 MB)
     |████████████████████████████████| 4.8 MB 376 kB/s 
Collecting protobuf<5.0dev,>=4.21.6
  Downloading http://mirrors.tencentyun.com/pypi/packages/4f/e0/9e8b77d79996f86e1ecf6622a693b5b116ea392f23c3758de5e902ba84ad/protobuf-4.21.10-cp37-abi3-manylinux2014_x86_64.whl (408 kB)
     |████████████████████████████████| 408 kB 514 kB/s 
Requirement already satisfied: setuptools in /usr/lib64/anaconda3/lib/python3.9/site-packages (from grpcio-tools) (58.0.4)
Installing collected packages: protobuf, grpcio, grpcio-tools
  Attempting uninstall: protobuf
    Found existing installation: protobuf 3.20.1
    Uninstalling protobuf-3.20.1:
      Successfully uninstalled protobuf-3.20.1
  Attempting uninstall: grpcio
    Found existing installation: grpcio 1.45.0
    Uninstalling grpcio-1.45.0:
      Successfully uninstalled grpcio-1.45.0
ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.
tensorboard 2.11.0 requires protobuf<4,>=3.9.2, but you have protobuf 4.21.10 which is incompatible.
Successfully installed grpcio-1.51.1 grpcio-tools-1.51.1 protobuf-4.21.10
WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv

# yum install git
# git clone -b v1.50.0 --depth 1  https://github.com/grpc/grpc

# cd grpc/examples/python/helloworld
# python greeter_server.py
# python greeter_client.py

# mkdir /home/jean/grpcTest
# cd /home/jean/grpcTest

# vi helloworld.proto

// Copyright 2015 The gRPC Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";

option java_multiple_files = true;
option java_package = "io.grpc.examples.helloworld";
option java_outer_classname = "HelloWorldProto";
option objc_class_prefix = "HLW";

package helloworld;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

python -m grpc_tools.protoc  -I.  --python_out=. --pyi_out=. --grpc_python_out=. helloworld.proto

# mkdir /opt/gradle
# cd /opt/gradle
# wget https://downloads.gradle-dn.com/distributions/gradle-7.6-bin.zip
# unzip -d /opt/gradle gradle-7.6-bin.zip

# vi /etc/profile
export PATH=$PATH:/opt/gradle/gradle-7.6/bin
# gradle -v

# git clone -b v1.51.0 --depth 1 https://github.com/grpc/grpc-java

# cd grpc-java/examples
# ./gradlew installDist

# ./build/install/examples/bin/hello-world-server
# ./build/install/examples/bin/hello-world-client

> git clone -b v1.51.0 --depth 1 https://github.com/grpc/grpc-java

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>jean</groupId>
    <artifactId>grpcserver</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>gRPCServer</name>

    <dependencies>
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>3.21.7</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-netty-shaded</artifactId>
            <version>1.51.0</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-protobuf</artifactId>
            <version>1.51.0</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-stub</artifactId>
            <version>1.51.0</version>
        </dependency>
        <!-- Removed from JDK11 and above, need to be added here -->
        <!-- https://blog.csdn.net/ml863606/article/details/109202246?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0-109202246-blog-120904477.pc_relevant_3mothn_strategy_recovery&spm=1001.2101.3001.4242.1&utm_relevant_index=3 -->
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.3.2</version>
        </dependency>
    </dependencies>

    <build>
        <defaultGoal>clean generate-sources compile install</defaultGoal>
        <plugins>
            <!-- compile proto file into java files -->
            <plugin>
                <groupId>com.github.os72</groupId>
                <artifactId>protoc-jar-maven-plugin</artifactId>
                <version>3.11.1</version>
                <executions>
                    <execution>
                        <phase>generate-sources</phase>
                        <goals>
                            <goal>run</goal>
                        </goals>
                        <configuration>
                            <includeMavenTypes>direct</includeMavenTypes>
                            <inputDirectories>
                                <include>src/main/resources</include>
                            </inputDirectories>
                            <outputTargets>
                                <outputTarget>
                                    <type>java</type>
                                    <outputDirectory>src/main/java</outputDirectory>
                                </outputTarget>
                                <outputTarget>
                                    <type>grpc-java</type>
                                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.51.0</pluginArtifact>
                                    <outputDirectory>src/main/java</outputDirectory>
                                </outputTarget>
                            </outputTargets>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.10.1</version>
                <configuration>
                    <source>11</source>
                    <target>11</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

    String target = "124.223.110.20:50051";

animal-sniffer-annotations-1.21.jar
annotations-4.1.1.4.jar
checker-qual-3.12.0.jar
error_prone_annotations-2.14.0.jar
failureaccess-1.0.1.jar
grpc-api-1.51.0.jar
grpc-auth-1.51.0.jar
grpc-context-1.51.0.jar
grpc-core-1.51.0.jar
grpc-netty-shaded-1.51.0.jar
grpc-protobuf-1.51.0.jar
grpc-protobuf-lite-1.15.1.jar
grpc-stub-1.51.0.jar
gson-2.9.0.jar
guava-20.0.jar
guava-31.1-android.jar
j2objc-annotations-1.3.jar
javax.annotation-api-1.3.2.jar
jsr305-3.0.2.jar
listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar
opencensus-api-0.12.3.jar
opencensus-contrib-grpc-metrics-0.12.3.jar
perfmark-api-0.25.0.jar
proto-google-common-protos-2.9.0.jar
protobuf-java-3.21.7.jar

GreeterGrpc.java             HelloReply.java
HelloReplyOrBuilder.java     HelloRequest.java            HelloRequestOrBuilder.java   
HelloWorldProto.java

package io.grpc.examples.helloworld;

import io.grpc.Channel;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.StatusRuntimeException;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * A simple client that requests a greeting from the {@link HelloWorldServer}.
 */
public class HelloWorldClient {
  private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());

  private final GreeterGrpc.GreeterBlockingStub blockingStub;

  private ManagedChannel channel=null;
 
  /** Construct client for accessing HelloWorld server by creating a channel. */
  public HelloWorldClient(String server, Integer port) {
 
    channel = ManagedChannelBuilder.forTarget(server+":"+port)
                // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
                // needing certificates.
                .usePlaintext()
                .build();
 
    // 'channel' here is a Channel, not a ManagedChannel, so it is not this code's responsibility to
    // shut it down.
    // Passing Channels to code makes code easier to test and makes it easier to reuse Channels.
    blockingStub = GreeterGrpc.newBlockingStub(channel);
  }

  /** Say hello to server. */
  public String greet(String name) {
    logger.info("Will try to greet " + name + " ...");
    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
    HelloReply response;
    try {
      response = blockingStub.sayHello(request);
    } catch (StatusRuntimeException e) {
      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
      return (e.toString());
    }
    logger.info("Greeting: " + response.getMessage());
    return (response.getMessage());
  }

  /** Close the channel. */
  public void close() throws Exception {
    try {
      // ManagedChannels use resources like threads and TCP connections. To prevent leaking these
      // resources the channel should be shut down when it will no longer be used. If it may be used
      // again leave it running.
      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
    }catch(Exception e) {
        e.printStackTrace();
    }
  }
}

<%@ page language="java" contentType="text/html; charset=GBK"
    pageEncoding="GBK"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=GBK">
<title>Java EE gRPC调用测试</title>
</head>
<body>
<center>
 <form action="callgrpc.jsp" method="post">
 跟用户打招呼 <br/>
  用户名:<input type="text" name="name" value="Jean"><br/>
 <input type="submit" value="打招呼">
 </form>
 </center>
</body>
</html>

<%@ page language="java" contentType="text/html; charset=GBK"
    pageEncoding="GBK"%>
<%@ page import="io.grpc.examples.helloworld.*"%>    
 
<%

String resp =null;
try{
 
    String user = new String(request.getParameter("name").getBytes("ISO-8859-1"),"GBK");
    if (user==null) user = "Jean";
    //String server = "localhost";
    String server = "jeanye.cn";
    Integer port = 50051;
 
    // Plain text without SSL & password.
    HelloWorldClient client = new HelloWorldClient(server, port);

    resp = client.greet(user);
    client.close();
 
}catch(Exception e){
    resp =e.toString();
}

%>    
<!DOCTYPE html>
<html>
<head>
<meta charset="GBK">
<title>Java EE 调用gRPC 测试</title>
</head>
<body>
Java gRPC调用服务器端Python程序结果：
<br>
<%= resp %>
<br>
<a href="index.jsp">返回</a>
</body>
</html>

# Copyright 2015 gRPC authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""The Python implementation of the GRPC helloworld.Greeter server."""

from concurrent import futures
import logging

import grpc
import helloworld_pb2
import helloworld_pb2_grpc

# The Class to serve the client with a Function defined by tha proto file.
class Greeter(helloworld_pb2_grpc.GreeterServicer):

    def SayHello(self, request, context):
        print(request.name)
        return helloworld_pb2.HelloReply(message='Hello, %s!' % request.name)

# For authenticating with a password.
class AuthInterceptor(grpc.ServerInterceptor):
    def __init__(self, key):
        # 'rpc-auth-header' is the header data containing the password.
        self._valid_metadata = ('rpc-auth-header', key)

        def deny(_, context):
            context.abort(grpc.StatusCode.UNAUTHENTICATED, 'Invalid key')

        self._deny = grpc.unary_unary_rpc_method_handler(deny)

    def intercept_service(self, continuation, handler_call_details):
        meta = handler_call_details.invocation_metadata
        print(meta)
        # https://grpc.io/docs/guides/auth/#extending-grpc-to-support-other-authentication-mechanisms
        # There's a bug in the document, meta[0] should be meta[1] for newer versions.
        if meta and meta[1] == self._valid_metadata:
            return continuation(handler_call_details)
        else:
            return self._deny


# The server procedure.
def serve():
    port = '50051'
    # Now requires authentication with a password by attaching an interceptor.
    # 'access_key' is the password.
    server = grpc.server(
                futures.ThreadPoolExecutor(max_workers=10),
                interceptors=(AuthInterceptor('access_key'),)
             )
    helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
    # Load the server's certificate chain & private key.
    # So the server should be run as root.
    with open('/root/cert/server.key', 'rb') as f:
        private_key = f.read()
    with open('/root/cert/server.crt', 'rb') as f:
        certificate_chain = f.read()
    with open('/root/cert/ca.crt', 'rb') as f:
        root_certificates = f.read()
    # False means client cert is not required.
    server_credentials = grpc.ssl_server_credentials(((private_key, certificate_chain),), root_certificates,False)
    # '[::]:' means may be accessed from any IP.
    server.add_secure_port('[::]:' + port, server_credentials)    
    server.start()
    print("Server started, listening on " + port)
    # May be interrupted by Ctrl+C.
    server.wait_for_termination()


if __name__ == '__main__':
    logging.basicConfig()
    serve()

# Copyright 2015 gRPC authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""The Python implementation of the GRPC helloworld.Greeter client."""

from __future__ import print_function

import logging

import grpc
import helloworld_pb2
import helloworld_pb2_grpc

# Class to add authentication header to the meta data of every gRPC call.
class GrpcAuth(grpc.AuthMetadataPlugin):
    def __init__(self, key):
        self._key = key

    # 'rpc-auth-header' is the authentication header defined by the server.
    def __call__(self, context, callback):
        callback((('rpc-auth-header', self._key),), None)


def run():
    # NOTE(gRPC Python Team): .close() is possible on a channel and should be
    # used in circumstances in which the with statement does not fit the needs
    # of the code.
    print("Will try to greet world ...")
    # Will fail for enpty credentials.
    # creds = grpc.ssl_channel_credentials()
    # Need to include root certificate in credentials.
    # https://stackoverflow.com/questions/72230151/how-to-open-a-secure-channel-in-python-grpc-client-without-a-client-ssl-certific
    # Copy the selfsigned CA's root cert to the client directory, so that the client doesn't need to be run as root.
    with open('ca.crt', 'rb') as f:
        creds = grpc.ssl_channel_credentials(f.read())
 
    # A composite channel credentials with SSL and password.
    # Host name need to be the same as the server certificate. 
    channel = grpc.secure_channel(
        'jeanye.cn:50051',
        grpc.composite_channel_credentials(
            creds,
            grpc.metadata_call_credentials(
                GrpcAuth('access_key')
                # A worng key will fail then.
                # GrpcAuth('wrong_access_key')
            )
        )
    )
 
    stub = helloworld_pb2_grpc.GreeterStub(channel)
    response = stub.SayHello(helloworld_pb2.HelloRequest(name='Jean'))
    print("Greeter client received: " + response.message)


if __name__ == '__main__':
    logging.basicConfig()
    run()

package io.grpc.examples.helloworld;

import io.grpc.Channel;
import io.grpc.ClientInterceptor;
import io.grpc.ClientInterceptors;
import io.grpc.ManagedChannel;
import io.grpc.StatusRuntimeException;
import io.grpc.netty.shaded.io.grpc.netty.GrpcSslContexts;
import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;

import java.io.File;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * A simple client that requests a greeting from the {@link HelloWorldServer}.
 */
public class HelloWorldClientSSLAuth {
    private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());

    private final GreeterGrpc.GreeterBlockingStub blockingStub;

    private ManagedChannel originChannel = null;
 
    private Channel channel = null;

    /** Construct client for accessing HelloWorld server by creating a channel. */
    public HelloWorldClientSSLAuth(String caFile, String server, Integer port) throws Exception {

        /* 
         * Use NettyChannelBuilder to build SSL connection to server.
         * https://stackoverflow.com/questions/42700411/ssl-connection-for-grpc-java-client
         * Need to include selfsigned CA certificate to build a sslContext to verify the server.
         * And the server name must be same as the name in the server certificate.
         */
        originChannel = NettyChannelBuilder.forAddress(server, port)
                .sslContext(GrpcSslContexts.forClient().trustManager(new File(caFile)).build())
                .build();  
        // "access_key" is the password to call gRPC.
        ClientInterceptor interceptor = new HeaderClientInterceptor("access_key");
        // Channel with an interceptor to add an auth header for each gRPC call.
        channel = ClientInterceptors.intercept(originChannel, interceptor);
 
        // 'channel' here is a Channel, not a ManagedChannel, so it is not this code's
        // responsibility to shut it down.
        // Passing Channels to code makes code easier to test and makes it easier to reuse Channels.
        blockingStub = GreeterGrpc.newBlockingStub(channel);
    }

    /** Say hello to server. */
    public String greet(String name) {
        logger.info("Will try to greet " + name + " ...");
        HelloRequest request = HelloRequest.newBuilder().setName(name).build();
        HelloReply response;
        try {
            response = blockingStub.sayHello(request);
        } catch (StatusRuntimeException e) {
            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
            return (e.toString());
        }
        logger.info("Greeting: " + response.getMessage());
        return (response.getMessage());
    }

    /** Close the channel. */
    public void close() throws Exception {
        try {
            // ManagedChannels use resources like threads and TCP connections. To prevent leaking these
            // resources the channel should be shut down when it will no longer be used. If
            // it may be used again leave it running.
            originChannel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/*
 * Copyright 2015 The gRPC Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package io.grpc.examples.helloworld;

import com.google.common.annotations.VisibleForTesting;
import io.grpc.CallOptions;
import io.grpc.Channel;
import io.grpc.ClientCall;
import io.grpc.ClientInterceptor;
import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
import io.grpc.Metadata;
import io.grpc.MethodDescriptor;
import java.util.logging.Logger;

/**
 * A interceptor to handle client header.
 */
public class HeaderClientInterceptor implements ClientInterceptor {

  private static final Logger logger = Logger.getLogger(HeaderClientInterceptor.class.getName());
  private String password = null;

  // This header is defined by the Python side to verify the client with a password.
  @VisibleForTesting
  static final Metadata.Key<String> CUSTOM_HEADER_KEY =
      Metadata.Key.of("rpc-auth-header", Metadata.ASCII_STRING_MARSHALLER);

  public HeaderClientInterceptor(String password) {
      this.password = password;
  }
 
  @Override
  public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method,
      CallOptions callOptions, Channel next) {
    return new SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {

      @Override
      public void start(Listener<RespT> responseListener, Metadata headers) {
        /* put custom header */
        headers.put(CUSTOM_HEADER_KEY, password);        
        super.start(new SimpleForwardingClientCallListener<RespT>(responseListener) {
          @Override
          public void onHeaders(Metadata headers) {
            /**
             * if you don't need receive header from server,
             * you can use {@link io.grpc.stub.MetadataUtils#attachHeaders}
             * directly to send header
             */
            logger.info("header received from server:" + headers);
            super.onHeaders(headers);
          }
        }, headers);
      }
    };
  }
}

<%@ page language="java" contentType="text/html; charset=GBK"
    pageEncoding="GBK"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=GBK">
<title>Java EE gRPC调用测试</title>
</head>
<body>
<center>
 <form action="callgrpc.jsp" method="post">
 跟用户打招呼 <br/>
  用户名:<input type="text" name="name" value="Jean"><br/>
 <input type="submit" value="打招呼">
 </form>
 </center>
</body>
</html>

<%@ page language="java" contentType="text/html; charset=GBK"
    pageEncoding="GBK"%>
<%@ page import="io.grpc.examples.helloworld.*"%>    
 
<%

String resp =null;
try{
 
    String user = new String(request.getParameter("name").getBytes("ISO-8859-1"),"GBK");
    if (user==null) user = "Jean";
    //String server = "localhost";
    String server = "jeanye.cn";
    Integer port = 50051;
 
    // Plain text without SSL & password.
    // HelloWorldClient client = new HelloWorldClient(server, port);
    String caFile =  application.getRealPath("/WEB-INF/ca.crt");
    // SSL without password.
    // HelloWorldClientSSL client = new HelloWorldClientSSL(caFile,server,port); 
    // SSL with password.
    HelloWorldClientSSLAuth client = new HelloWorldClientSSLAuth(caFile,server,port);    

    resp = client.greet(user);
    client.close();
 
}catch(Exception e){
    resp =e.toString();
}