Adres IP Klienta, WebService :: 4programmers.net

0

Czy możliwe jest uzyskanie adresu IP klienta, wywołującego metode WebService?
Tworze przykładowy serwer:

package test.service;

import javax.jws.WebService;
import javax.jws.WebMethod;
import javax.jws.WebParam;

@WebService(name="Test", serviceName="Test")
public class Test_service {
	@WebMethod
	public String hello() {
		return "Hello [ipadress]";
	}
}

I odpalam to z klasy:

import javax.xml.ws.Endpoint;
import test.service.Test_service;

public class Test {
	public static void main(String[] args) {
		System.out.println("Uruchamianie...");
		
		Test_service serv=new Test_service();
		Endpoint.publish("http://localhost:8080/test/Test",serv);
		
		System.out.println("Uruchomiono!");
	}
}

Robie wsgen:
wsgen -cp . test.service.Test_service -wsdl
Teraz twoże przykładowego klienta:
wsimport -p test.client -wsdllocation http://localhost:8080/test/Test?WSDL Test.wsdl

import javax.xml.ws.WebServiceRef;
import test.client.Test;
import test.client.Test_Service;

public class Client {
	@WebServiceRef(wsdlLocation="http://localhost:8080/test/Test?wsdl")
	public static void main(String[] args) {
		Test_Service service = new Test_Service();
		Test proxy = service.getTestPort();
		
		System.out.println(proxy.hello());
	}
}

Chciałbym, by metoda

hello()

zwracała adres IP klienta ją wywołującego.

0

;/
Nie musi być koniecznie dla WebService, może byc np.: dla RMI.

0

Kiedyś w aplecie tak pobierałem adres IP:

private String MyIP(boolean flag)
    {
        String s1 = "unknown";
        String s2 = getDocumentBase().getHost();
        int i = 80;
        if(getDocumentBase().getPort() != -1)
            i = getDocumentBase().getPort();
        try
        {
            String s = (new Socket(s2, i)).getLocalAddress().getHostAddress();
            if(!s.equals("255.255.255.255"))
                s1 = s;
        }
        catch(SecurityException _ex)
        {
            s1 = "FORBIDDEN";
        }
        catch(Exception _ex)
        {
            s1 = "ERROR";
        }
        if(flag)
            try
            {
                s1 = (new Socket(s2, i)).getLocalAddress().getHostName();
            }
            catch(Exception _ex)
            {
                Stat = "Cannot Lookup this IP";
            }
        return s1;
    }

Chyba zwracało IP lokalne komputera (wewnętrzne, lanowskie, czy jak to tam nazywać).
Mam nadzieję, że się przyda.
Pozdrawiam

0

W klasie reprezentujacej usluge sieciowa zadeklaruj sobie kontekst uslugi:

@WebService
public class TheWebService {
    @Resource
    private WebServiceContext wsContext;
    //...
}

Dzieki niemu, w Swoich metodach sieciowych, bedziesz mial dostep do MessageContext, a stad juz wystarczy wyciagnac MessageContext.SERVLET_REQUEST i jestes w domu.
Pozdr.

0

No tak, aby to działało musiałbym postawić serwer przy pomocy servletu. Do tej pory używałem serwera wbudowanego w Jave SE 6.0.

Zatem, czy ktoś zechciałby mi wyjaśnić (bądź pokazać dobry tutorial) jak majac do dyspozycji:

JDK SE 6.0
Tomcat
Notatnik
postawić powyższą usługe sieciową.

0

WebServices: JDK 6.0, Tomcat 5.5.17, JAX-WS 2.1

0. Sciagamy JAXWS-RI ze strony https://jax-ws.dev.java.net/ri-download.html.

1. W katalogu JDK\jre\lib tworzymy nowy podkatalog "endorsed" i kopiujemy do niego biblioteki jaxws-api.jar, jaxb-api.jar i servlet-api.jar.

2. Tworzymy strukture katalogow:

webservice
|--classes
|--src
   |--ws
      |--WSHello.java
      |--client
         |--WSClient.java
|--WEB-INF
   |--lib

Zakladam, ze biezacy katalog, z ktorego wywolywane sa polecenia to "webservice".
Do katalogu WEB-INF/lib przerzucamy biblioteki JAXWS-RI.

3. Tworzymy klase uslugi sieciowej (WSHello.java):

package ws;

import javax.annotation.Resource;
import javax.jws.WebService;
import javax.jws.WebMethod;
import javax.servlet.ServletRequest;
import javax.xml.ws.WebServiceContext;
import javax.xml.ws.handler.MessageContext;

@WebService
public class WSHello {
	@Resource
	private WebServiceContext wsContext;

	@WebMethod
	public String hello() {
		MessageContext mc = wsContext.getMessageContext();
		ServletRequest sr = (ServletRequest) mc.get(MessageContext.SERVLET_REQUEST);
		return sr.getRemoteHost();
	}
}

4. Kompilujemy klase uslugi i generujemy artefakty:
javac -d classes src/ws/WSHello.java
wsgen -cp classes -d classes -s src -r WEB-INF ws.WSHello -wsdl

5. Tworzymy pliki deskryptorow uslugi (sun-jaxws.xml):

<?xml version="1.0" encoding="UTF-8"?>
<endpoints xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime" version="2.0">
	<endpoint
		name="WSHello"
		implementation="ws.WSHello"
		url-pattern="/hello"
		/>
</endpoints>

i aplikacji webowej (web.xml):

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
	<listener>
		<listener-class>com.sun.xml.ws.transport.http.servlet.WSServletContextListener</listener-class>
	</listener>
	<servlet>
		<servlet-name>hello</servlet-name>
		<servlet-class>com.sun.xml.ws.transport.http.servlet.WSServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>hello</servlet-name>
		<url-pattern>/hello</url-pattern>
	</servlet-mapping>
	<session-config>
		<session-timeout>60</session-timeout>
	</session-config>
</web-app>

Oba pliki powinny byc umieszczone w katalogu WEB-INF.

6. Tworzymy archiwum aplikacji:
Po przekopiowaniu calego katalogu "classes" do WEB-INF robimy:
jar cvfM ws-test.war WEB-INF

7. Stworzone archiwum .war wrzucamy do katalogu "webapps" Tomcat'a. Od tej pory usluga dostepna jest pod adresem:
http://localhost:8080/ws-test/hello?wsdl

8. Tworzenie klienta (WSClient.java):

package ws.client;

import javax.xml.ws.WebServiceRef;

@WebServiceRef(wsdlLocation="http://localhost:8080/ws-hello/hello?wsdl")
public class WSClient {
	public static final void main(String[] args) {
		WSHelloService service = new WSHelloService();
		WSHello port = service.getWSHelloPort();
		System.out.println(port.hello());
	}
}

wsimport -p ws.client -d classes -s src -wsdllocation http://localhost:8080/ws-test/hello?wsdl WEB-INF/WSHelloService.wsdl
javac -sourcepath src -d classes src/ws/client/WSClient.java

Tworzymy plik manifestu (MANIFEST.MF):

Manifest-Version: 1.0
Created-By: 1.6.0_02 (Sun Microsystems Inc.)
Main-Class: ws.client.WSClient

i pakujemy do .jar'a:

jar cvfm ws-client.jar MANIFEST.MF -C classes ws/client/

Java RMI

0. Tworzymy strukture katalogow:

rmi
|--remote
   |--client
      |--Client.java
   |--MyService.java
   |--MyServiceImpl.java
|--client.policy
|--server.policy

Dla testow zawartosc plikow "client.policy" i "server.policy":

grant codeBase "file:." {
    permission java.security.AllPermission;
};

1. Tworzymy zdalny interfejs uslugi (MyService.java)

package remote;

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface MyService extends Remote {
	public abstract String hello() throws RemoteException;
}

2. Tworzymy implementacje zdalnego interfejsu (MyServiceImpl.java)

package remote;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.RemoteServer;
import java.rmi.server.ServerNotActiveException;
import java.rmi.server.UnicastRemoteObject;
import remote.MyService;

public class MyServiceImpl implements MyService {

	public MyServiceImpl() {
		super();
	}

	public String hello() {
		String host = null;
		try {
			String remoteHost = RemoteServer.getClientHost();
			InetAddress inet = InetAddress.getByName(remoteHost);
			host = inet.getHostAddress();
		} catch(ServerNotActiveException snae) {
			System.err.println("Exception in method. Reason: " + snae.getMessage());
			snae.printStackTrace();
		} catch(UnknownHostException uhe) {
			System.err.println("Exception in method. Reason: " + uhe.getMessage());
			uhe.printStackTrace();
		}
		return host;
	}

	public static final void main(String[] args) {
		if(System.getSecurityManager() == null) {
			System.setSecurityManager(new SecurityManager());
		}
		try {
			String name = "MyService";
			MyService service = new MyServiceImpl();
			MyService stub = (MyService) UnicastRemoteObject.exportObject(service, 0);
			Registry registry = LocateRegistry.getRegistry();
			registry.rebind(name, stub);
			System.out.println("Service registered");
		} catch(Exception e) {
			System.err.println("Exception occured: " + e.getMessage());
			e.printStackTrace();
		}
	}
}

3. Kompilujemy pliki
javac remote/*.java

4. Uruchamiamy usluge RMI
start rmiregistry
java -cp . -Djava.security.policy=server.policy remote.MyServiceImpl

5. Tworzymy klienta

package remote.client;

import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import remote.MyService;

public class Client {
	public static final void main(String[] args) {
		if(System.getSecurityManager() == null) {
			System.setSecurityManager(new SecurityManager());
		}
		try {
			String name = "MyService";
			Registry registry = LocateRegistry.getRegistry("localhost");
			MyService service = (MyService) registry.lookup(name);
			System.out.println("Received host: " + service.hello());
		} catch(Exception e) {
			System.out.println("Client's exception: " + e.getMessage());
			e.printStackTrace();
		}
	}
}

... i kompilujemy:
javac remote/client/Client.java

6. Uruchamiamy klienta
java -cp . -Djava.security.policy=client.policy remote.client.Client

0

Wielkie dzięki ;)

Właśnie o takie wyjaśnienie mi chodziło.

Adres IP Klienta, WebService

1 użytkowników online, w tym zalogowanych: 0, gości: 1

Praca dla programistów

Forum dyskusyjne

Sprawy administracyjne

O nas

Skontaktuj się z nami