wayne

2008年9月13日 #

JMS (2)

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

 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，实际上这一步是不可缺少的。

posted @ 2008-09-14 16:40 waynemao 阅读(108) | 评论 (0) | 编辑 收藏

JMS (1)

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

posted @ 2008-09-14 05:31 waynemao 阅读(307) | 评论 (0) | 编辑 收藏

EJB3 (7)

有状态会话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方法。

posted @ 2008-09-13 11:14 waynemao 阅读(181) | 评论 (0) | 编辑 收藏

EJB3 (6)

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），只有一个能有效使用（只找到一份工件），这是为什么？

posted @ 2008-09-13 04:36 waynemao 阅读(136) | 评论 (0) | 编辑 收藏

WebService (1)

新建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"?><!-- Published by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.1.3.1-hudson-417-SNAPSHOT. --><!-- Generated by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.1.3.1-hudson-417-SNAPSHOT. -->
<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
        }
    }
}

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

posted @ 2008-09-13 02:31 waynemao 阅读(155) | 评论 (0) | 编辑 收藏

oracle视频

oracle10g_1

oracle10g_2

oracle10g_3_1

oracle10g_3_2

oracle10g_4_1

oracle10g_4_2

oracle10g_5_1

oracle10g_5_2

oracle10g_6

oracle10g_7_1

oracle10g_7_2

oracle10g_8

oracle10g_9

oracle10g_10

oracle10g_11

oracle10g_12

oracle10g_13

oracle10g_14

posted @ 2008-09-13 01:01 waynemao 阅读(152) | 评论 (0) | 编辑 收藏

EJB3 (5)

同一个会话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("<br>" + helloBean1.sayBye("Tom"));
%>

和Servlet中的一样

posted @ 2008-09-13 00:42 waynemao 阅读(131) | 评论 (0) | 编辑 收藏

EJB3 (4)

如果一个远程接口有两个实现，需要用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("<br>" + helloBean2.sayHi("Tom"));
%>

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

posted @ 2008-09-13 00:21 waynemao 阅读(164) | 评论 (0) | 编辑 收藏

My Links

Blog Stats

常用链接

留言簿(1)

随笔分类

随笔档案

default

搜索

最新评论

阅读排行榜

评论排行榜