语源科技BlogJava-wayne

JMS (2)

waynemao — Sun, 14 Sep 2008 08:40:00 GMT

异步队列消息的接收有一点区别，但发送的代码不用改变：

1@Stateless
2public class JMSReceiveBean implements JMSReceiveRemote {
3
4    @Resource(name = "jms/Queue")
5    private Queue queue;
6    @Resource(name = "jms/ConnectionFactory")
7    private ConnectionFactory queueFactory;
8
9    private void receiveJMSMessageFromQueue() throws Exception {
10        Connection connection = null;
11        Session session = null;
12        connection = queueFactory.createConnection();
13        session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);
14        MessageConsumer consumer = session.createConsumer(queue);
15        consumer.setMessageListener(new MessageListener() {
16
17            public void onMessage(Message message) {
18                TextMessage msg = (TextMessage) message;
19                try {
20                    String txt = msg.getText();
21                    Logger.getLogger(JMSReceiveBean.class.getName()).log(Level.SEVERE, txt);
22                } catch (Exception ex) {
23                    ex.printStackTrace();
24                }
25            }
26        });
27
28        connection.start();
29    }
30
31    public void receiveMessage() {
32        try {
33            receiveJMSMessageFromQueue();
34        } catch (Exception ex) {
35            Logger.getLogger(JMSReceiveBean.class.getName()).log(Level.SEVERE, null, ex);
36        }
37    }
38}

在15行消息使用者上设置了一个消息监听器，而没有使用同步的receive方法。由于这是异步接收消息，程序并没有处于阻塞状态，为了避免在接收到消息之前连接终止，所以在28行之后并没有关闭Connection，实际上这一步是不可缺少的。

waynemao 2008-09-14 16:40 发表评论

JMS (1)

waynemao — Sat, 13 Sep 2008 21:31:00 GMT

摘要: 开发任何JMS应用之前，首先要做的事是在应用服务器中配置JMS被管对象：连接工厂和目的地。它们最好不要以编程的方式实现，因为其背后的技术有多种不同的API实现，可能无法移植。以下是glassfish中的配置：在配置--java消息服务里创建两个物理目的地名称：myQueue 类型：javax.jms.Queue 名称：myTopic 类... 阅读全文

waynemao 2008-09-14 05:31 发表评论

EJB3 (7)

waynemao — Sat, 13 Sep 2008 03:14:00 GMT

有状态会话bean的开发，首先创建远程接口：

@Remote
public interface HelloRemote {

    String sayHi();

    void init(String name);

    void remove();

}

接着开发有状态会话bean：

@Stateful
public class HelloBean implements HelloRemote {
    private String name;
    private Logger log = Logger.getLogger(this.getClass().getName());

    public String sayHi() {
        return "Hi " + name;
    }

    public void init(String name) {
        this.name = name;
    }

    @PostConstruct
    public void postConstrut(){
        log.info("create " + this);
    }

    @PreDestroy
    public void preDestory(){
        log.info("destory " + this);
    }

    @PostActivate
    public void postActivate(){
        log.info("activate " + this);
    }

    @PrePassivate
    public void prePassivate(){
        log.info("passivate " + this);
    }

    @Remove
    public void remove(){
        log.info("remove " + this);
    }
}

@Stateful注释表明这是一个有状态会话bean，其他的注释是管理会话bean的生命周期。@PostConstruct注释表明方法将会在bean实例化并完成依赖注入后由容器调用此方法；@PreDestory注释表示方法会在容器删除bean实例前由容器调用；以上两个注释所有的EJB（包括MDB）都可以用。@PostActivate注释表示容器在激活bean后调用此方法；@PrePassivate注释表示容器在钝化bean前调用此方法；以上两个注释是有状态会话bean所特有。@Remove注释也是有状态会话bean所特有，也是用户唯一可以能控制的生命周期方法，一旦用户在客户端调用此方法，容器将删除bean实例。接着看客户端的测试代码：

<%
           InitialContext ctx = new InitialContext();
           HelloRemote helloBean = (HelloRemote)ctx.lookup(HelloRemote.class.getName());
           helloBean.init("Tom");
           out.println(helloBean.sayHi());
           helloBean.remove();
%>

很简单，只是多调用了一个remove方法。

waynemao 2008-09-13 11:14 发表评论

EJB3 (6)

waynemao — Fri, 12 Sep 2008 20:36:00 GMT

Web服务客户端可以通过bean的Web服务端点实现类来访问无状态会话Bean。在默认情况下，bean类中的所有公共方法对于Web服务客户端都是可访问的。@WebMethod注释可以自定义Web服务方法，一旦在公共方法上使用该注释，那么其他没使用@WebMethod注释的方法将不会对Web服务客户端展现。
首先新建一个EJB模块，然后在EJB模块上新建一个WebService，代码如下：

@WebService()
@Stateless()
public class Dog {

    @WebMethod(operationName = "ganr")
    public String ganr() {
        return "Wo-Wo-Wo";
    }

}

Dog类同时使用了@WebService和@Stateless注释，web服务端点只能是无状态会话bean，web服务本身就是无状态的。我们还用@WebMethod注释向Web服务客户端公开了一个ganr方法，完成后打包部署。
接着我们创建一个Web模块，然后在Web项目上右键，选新建--Web服务客户端，指定项目或者WSDL url。接着新建一个Servlet，然后右键调用Web服务操作，我们找到Dog服务的garn方法点确定，代码自动生成：

@WebServiceRef(wsdlLocation = "http://localhost:8080/DogService/Dog?wsdl")
private DogService service;

@WebServiceRef注释声明了一个到Web服务的引用

try { // Call Web Service Operation

                ejb.Dog port = service.getDogPort();
                // TODO process result here
                java.lang.String result = port.ganr();
                out.println("Result = " + result);
            } catch (Exception ex) {
                // TODO handle custom exceptions here
            }

service.getDogPort()方法获取到服务的一个代理，也称为端口。接着看jsp：

  <%
    try {
    ejb.DogService service = new ejb.DogService();
    ejb.Dog port = service.getDogPort();
    // TODO process result here
    java.lang.String result = port.ganr();
    out.println("Result = "+result);
    } catch (Exception ex) {
    // TODO handle custom exceptions here
    }
    %>

发现只有一点点不同，完成后部署web应用并运行测试。

我们还可以通过一个现有的会话Bean创建Web服务，还是拿HelloWorld举例，首先创建一个远程接口：

@Remote
public interface HelloRemote {

String sayHi(String name);
}

再创建一个无状态会话bean，先已经说过了，只能是无状态会话bean：

@Stateless
public class HelloBean implements HelloRemote {

    public String sayHi(String name) {
        return "Hi " + name;
    }
}

然后新建一个Web服务Hello，只不过在弹出窗口中要选中“通过现有会话bean创建Web服务”单选框，并浏览指定HelloBean，代码自动完成：

@WebService()
@Stateless()
public class Hello {
    @EJB
    private HelloRemote ejbRef;
    // Add business logic below. (Right-click in editor and choose
    // "Web Service > Add Operation"

    @WebMethod(operationName = "sayHi")
    public String sayHi(@WebParam(name = "name")String name) {
        return ejbRef.sayHi(name);
    }
}

我们看到Hello服务里引用了一个HelloRemote接口，并发现远程接口公开的方法也被Hello服务公开，完成后打包部署EJB模块。接着在Web服务客户端测试，这和之前的步骤一样，不再赘述，直接看代码吧：

@WebServiceRef(wsdlLocation = "http://localhost:8080/HelloService/Hello?wsdl")
    private HelloService service;

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            try { // Call Web Service Operation

                ejb.Hello port = service.getHelloPort();
                // TODO initialize WS operation arguments here
                java.lang.String name = "Tom";
                // TODO process result here
                java.lang.String result = port.sayHi(name);
                out.println("Result = " + result);
            } catch (Exception ex) {
                // TODO handle custom exceptions here
            }

<%
    try {
    ejb.HelloService service = new ejb.HelloService();
    ejb.Hello port = service.getHelloPort();
     // TODO initialize WS operation arguments here
    java.lang.String name = "Tom";
    // TODO process result here
    java.lang.String result = port.sayHi(name);
    out.println("Result = "+result);
    } catch (Exception ex) {
    // TODO handle custom exceptions here
    }
    %>

发现一个问题，一个应用上不能新建两个Web服务客户端（Dog和Hello），只有一个能有效使用（只找到一份工件），这是为什么？

waynemao 2008-09-13 04:36 发表评论

WebService (1)

waynemao — Fri, 12 Sep 2008 18:31:00 GMT

新建web项目，然后创建一个WEB服务：

@WebService()
public class Hello {
    @WebMethod(operationName = "sayHi")
    public String sayHi(@WebParam(name = "name")String name) {
       return "Hi " + name;
    }
}

可以在源图上右键，选Web服务--添加操作，也可以在设计图上直接添加操作。@WebService标注表明该类是一个web服务，展现给web服务客户端的业务方法必须使用@WebMethod标注来表示。打包部署该web应用，web服务自动会发布。可以在glassfish应用服务器上找到该web服务，直接测试或者查看服务器生成的WSDL

xml version="1.0" encoding="UTF-8"?>
<definitions xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://webservice/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.xmlsoap.org/wsdl/" targetNamespace="http://webservice/" name="HelloService">
    <types>
        <xsd:schema>
            <xsd:import namespace="http://webservice/" schemaLocation="http://localhost:8080/WebServiceApp/HelloService?xsd=1">
            xsd:import>
        xsd:schema>
    types>
    <message name="sayHi">
        <part name="parameters" element="tns:sayHi">
        part>
    message>
    <message name="sayHiResponse">
        <part name="parameters" element="tns:sayHiResponse">
        part>
    message>
    <portType name="Hello">
        <operation name="sayHi">
            <input message="tns:sayHi">
            input>
            <output message="tns:sayHiResponse">
            output>
        operation>
    portType>
    <binding name="HelloPortBinding" type="tns:Hello">
        <soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="document">
        soap:binding>
        <operation name="sayHi">
            <soap:operation soapAction="">
            soap:operation>
            <input>
                <soap:body use="literal">
                soap:body>
            input>
            <output>
                <soap:body use="literal">
                soap:body>
            output>
        operation>
    binding>
    <service name="HelloService">
        <port name="HelloPort" binding="tns:HelloPortBinding">
            <soap:address location="http://localhost:8080/WebServiceApp/HelloService">
            soap:address>
        port>
    service>
definitions>

也可以编写客户端测试，新建一个普通的java项目，在项目上右键，选择新建--Web服务客户端，在弹出窗口中指定WebService项目或者WSDL url，点击完成。在源代码上右键，选择Web服务客户端资源--调用Web服务操作，在弹出窗口中选择sayHi操作，点确定，测试代码自动生成：

public class Main {

    public static void main(String[] args) {

        try {

            webservice.HelloService service = new webservice.HelloService();
            webservice.Hello port = service.getHelloPort();

            java.lang.String name = "Tom";
            java.lang.String result = port.sayHi(name);
            System.out.println("Result = " + result);
        } catch (Exception ex) {
            // TODO handle custom exceptions here
        }
    }
}

运行该客户端，结果将会输出

waynemao 2008-09-13 02:31 发表评论

oracle视频

waynemao — Fri, 12 Sep 2008 17:01:00 GMT

waynemao 2008-09-13 01:01 发表评论

EJB3 (5)

waynemao — Fri, 12 Sep 2008 16:42:00 GMT

同一个会话bean也可以实现多个远程接口，不过代码上有些地方要注意，首先写第一个接口：

@Remote
public interface HelloRemote {

String sayHi(String name);
}

第二个接口：

@Remote
public interface HelloRemote1 {

String sayBye(String name);
}

接下来写会话bean，同时实现以上两个接口：

@Stateless(mappedName="hello")
public class HelloBean implements HelloRemote, HelloRemote1 {

    public String sayHi(String name) {
        return "Hi " + name;
    }

    public String sayBye(String name) {
        return "Bye " + name;
    }
}

注意这里用到了mappedName元素，这个很关键。把EJB模块打包部署，接下来在远程客户端测试，先写Servlet：

    @EJB(mappedName="hello#ejb.HelloRemote1")
    private HelloRemote1 helloBean1;
    @EJB(mappedName="hello#ejb.HelloRemote")
    private HelloRemote helloBean;

注意@EJB标注里也使用了mappedName元素，值的样式是：JNDI名#包名.接口名。再看Jsp：

<%
            InitialContext ctx = new InitialContext();
            HelloRemote helloBean = (HelloRemote)ctx.lookup("hello#ejb.HelloRemote");
            out.println(helloBean.sayHi("Tom"));
            HelloRemote1 helloBean1 = (HelloRemote1)ctx.lookup("hello#ejb.HelloRemote1");
            out.println("
" + helloBean1.sayBye("Tom"));
%>

和Servlet中的一样

waynemao 2008-09-13 00:42 发表评论

EJB3 (4)

waynemao — Fri, 12 Sep 2008 16:21:00 GMT

如果一个远程接口有两个实现，需要用mappedName来区分
首先定义一个远程接口：

@Remote
public interface HelloRemote {

String sayHi(String name);
}

第一个实现：

@Stateless(mappedName="hello")
public class HelloBean implements HelloRemote {

    public String sayHi(String name) {
        return "Hi " + name;
    }
}

第二个实现：

@Stateless(mappedName="hello2")
public class HelloBean2 implements HelloRemote{

    public String sayHi(String name) {
        return "Hello " + name;
    }

}

两个无状态会话bean实现了同一个远程接口，但它们的mappedName不一样，还有它们各自重写了sayHi业务方法。部署EJB模块然后测试，首先是Servlet：

    @EJB(mappedName="hello2")
    private HelloRemote helloBean2;
    @EJB(mappedName="hello")
    private HelloRemote helloBean;

然后是JSP：

<%
            InitialContext ctx = new InitialContext();
            HelloRemote helloBean = (HelloRemote)ctx.lookup("hello");
            out.println(helloBean.sayHi("Tom"));
            HelloRemote helloBean2 = (HelloRemote)ctx.lookup("hello2");
            out.println("
" + helloBean2.sayHi("Tom"));
%>

呵呵，远程调用也实现了多态

waynemao 2008-09-13 00:21 发表评论

EJB3 (3)

waynemao — Fri, 12 Sep 2008 14:24:00 GMT

我想在远程对象中调用本地对象，我尝试这样编写代码，首先创建一个本地接口：

@Local
public interface MessageLocal {

String getMessage();

}

接着编写一个会话bean实现该接口：

@Stateless
public class MessageBean implements MessageLocal {

    public String getMessage() {
        return "Hello world";
    }

}

然后创建一个远程接口：

@Remote
public interface HelloRemote {

String welcome();

}

编写一个会话bean实现该接口：

@Stateless
public class HelloBean implements HelloRemote {
    @EJB
    private MessageLocal messageBean;

    public String welcome() {
        return messageBean.getMessage();
    }

}

在远程对象里声明了一个本地接口的引用，并尝试在远程方法当中调用本地接口的本地方法。这些都没问题，打包部署成功。

<%
            InitialContext ctx = new InitialContext();
            HelloRemote helloBean = (HelloRemote)ctx.lookup(HelloRemote.class.getName());
            out.println(helloBean.welcome());
%>

在远程客户端的代码如此，看起来一切正常，不过在部署WEB模块的时候报异常：正在域中部署应用程序失败；为模块 [EjbWebClient] 装入部署描述符时出错 -- Cannot resolve reference Unresolved Ejb-Ref ejb.HelloBean/messageBean@jndi: @null@ejb.MessageLocal@Session@null

waynemao 2008-09-12 22:24 发表评论

EJB3 (2)

waynemao — Fri, 12 Sep 2008 13:29:00 GMT

一个会话bean即可以远程访问，也可以本地访问，尽管这种现象不常见。
我们先定义远程接口：

@Remote
public interface HelloRemote {

    String sayHi(String name);

    String sayByeBye(String name);

}

接着定义本地接口：

@Local
public interface HelloLocal {

String sayBye(String name);

}

然后编写一个会话bean同时实现两个接口：

@Stateless
public class HelloBean implements HelloRemote, HelloLocal {

    public String sayHi(String name) {
        return "Hi " + name;
    }

    public String sayBye(String name) {
        return "Bye " + name;
    }

    public String sayByeBye(String name) {
        return sayBye(name);
    }

}

那么，这还是一个无状态会话bean，不过即可以远程访问，也可以本地访问。

<%
            InitialContext ctx = new InitialContext();
            HelloRemote helloBean = (HelloRemote)ctx.lookup(HelloRemote.class.getName());
            out.println(helloBean.sayHi("Tom"));
            out.println("
" + helloBean.sayByeBye("Tom"));
%>

远程访问只能获得远程接口的代理，然后调用远程业务方法。在远程客户端是无法获得本地接口的引用，更别说访问本地方法了。

waynemao 2008-09-12 21:29 发表评论