待到道成日，纵横天地间！ http://www.guloulou.com 追随我心：狂热的开发爱好者！ Mon, 23 Aug 2010 11:21:12 +0000 http://wordpress.org/?v=2.9.2 en hourly 1 26，27两讲采用@Resource注入报错原因 http://www.guloulou.com/?p=1996 http://www.guloulou.com/?p=1996#comments Mon, 09 Aug 2010 09:21:30 +0000 guloulou http://www.guloulou.com/?p=1996 上两讲每次运行，结果不错，但控制台会打印类似如下错误；详见27讲（http://www.guloulou.com/?p=1991）

deployed with moduleid = DemoSSH
NAM0006: 未找到 JMS 目标对象: cn.itcast.service.impl.PersonServiceBean/sessionFactory
javax.naming.NameNotFoundException

后来突然想到黎活明老师讲解时强调要建立J2EE1.4的工程。我不会是建立了J2EE5的工程了吧。两个版本对servlet的支持不一样；一查，果然如此。且看两个版本默认的 web.xml 开始定义

J2EE1.4的web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
 xmlns="http://java.sun.com/xml/ns/j2ee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
 http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

J2EE5的web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"> 

这个错误让俺查找了一整天。还是基础知识没掌握好。

]]> http://www.guloulou.com/?feed=rss2&p=1996 2 27_传智播客Spring2.5视频教程_Struts与Spring集成方案1(Struts集成Spring) http://www.guloulou.com/?p=1991 http://www.guloulou.com/?p=1991#comments Thu, 05 Aug 2010 14:21:08 +0000 guloulou http://www.guloulou.com/?p=1991 27_传智播客Spring2.5视频教程_Struts与Spring集成方案1(Struts集成Spring)
业务层木有问题了。现在我们开发view层、ctrl层；集成struts
添加jar包
bsf-2.3.0.jar                       
commons-beanutils-1.8.0.jar         
commons-chain-1.2.jar               
commons-digester-1.8.jar            
commons-fileupload-1.1.1.jar        
commons-io-1.1.jar                  
commons-logging-1.0.4.jar           
commons-validator-1.3.1.jar         
jstl-1.0.2.jar                      
oro-2.0.8.jar                       
standard-1.0.6.jar                  
struts-core-1.3.10.jar              
struts-el-1.3.10.jar                
struts-extras-1.3.10.jar            
struts-faces-1.3.10.jar             
struts-mailreader-dao-1.3.10.jar    
struts-scripting-1.3.10.jar         
struts-taglib-1.3.10.jar            
struts-tiles-1.3.10.jar            
注意没有添加antlr-2.7.2.jar这个语法分析包，因为在hibernate中已有antlr-2.7.6.jar；
使用listener实例化容器
原来我们Spring容器的实例化，是在单元测试中手工编码实例化的；现在我们采用Spring容器提供的监听器listener来实例化Spring容器；
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:beans.xml</param-value>
</context-param>
<!-- 对Spring容器进行实例化 -->
<listener>
    <listener-class>org.springframework.web.context.contextLoaderListener</listener-class>
</listener>
在web容器中配置struts
<servlet>
    <servlet-name>struts</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <init-param>
        <param-name>config</param-name>
        <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>struts</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>
 
新建struts配置文件:struts-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
"http://struts.apache.org/dtds/struts-config_1_3.dtd">
<struts-config>
</struts-config>
创建action：PersonAction.java
public class PersonAction extends Action {
 
    @Override
    public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
        return super.execute(mapping, form, request, response);
    }
 
}
配置action，配置forward
<action path="/person/list" type="cn.itcast.web.action.PersonAction" validate="false">
    <forward name="list" path="/WEB-INF/page/personlist.jsp" />
</action>
创建jsp:personlist.jsp
<c:forEach items="${persons}" var="person">
    ID=${person.id},name=${person.name}
</c:forEach>
集成Struts的思路
流程：请求-->action->forward->jsp
action中调用service层的业务方法，处理请求，然后根据forward配置跳转到对应jsp
上源码：
bean.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${driverClassName}" />
        <property name="url" value="${url}" />
        <property name="username" value="${username}" />
        <property name="password" value="${password}"/>
        <!-- 连接池启动时的初始值 -->
        <property name="initialSize" value="${initialSize}" />
        <!-- 连接池的最大值 -->
        <property name="maxActive" value="${maxActive}"/>
        <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
        <property name="maxIdle" value="${maxIdle}"/>
        <!-- 最小空闲值，当空闲的连接数少于阀值时，连接池就会去申请一些连接，以免洪峰来时来不及申请 -->
        <property name="minIdle" value="${minIdle}" />
    </bean>
    <bean id = "sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="mappingResources">
            <list>
                <value>cn/itcast/bean/Person.hbm.xml</value> <!-- 可以有多个Hibernate实体bean的映射文件 -->
            </list>
        </property>
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
                hibernate.hbm2ddl.auto=update
                hibernate.show_sql=false
                hibernate.format_sql=false
            </value>
        </property>
    </bean>
    <!-- Spring 针对Hibernate提供的事务管理器 -->
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean" />
    <!-- 采用注解的方式进行事务声明 -->
    <tx:annotation-driven transaction-manager="txManager"/>
    <context:annotation-config/>
 
</beans>
jdbc.properties
# To change this template, choose Tools | Templates
# and open the template in the editor.
driverClassName =org.gjt.mm.mysql.Driver
url=jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8
username=root
password=
initialSize =1
maxActive=500
maxIdle=2
minIdle=1
Person.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
 
<!--
    Document : Person.hbm.xml
    Created on : 2010年7月31日, 上午1:42
    Author : kang.cunhua
    Description:
        Purpose of the document follows.
-->
 
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.bean">
    <class name="Person" table="person">
        <id name="id" type="integer">
            <generator class="native"/>
        </id>
        <property name="name" length="10" not-null="true"/>
    </class>
</hibernate-mapping>
Person.java
package cn.itcast.bean;
 
/**
 *
 * @author kang.cunhua
 */
public class Person {
 
    private Integer id;
    private String name;
 
    public Person() {
    }
 
    public Person(String name) {
 
        this.name = name;
    }
 
    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
 
    /**
     * @return the id
     */
    public Integer getId() {
        return id;
    }
 
    /**
     * @param id the id to set
     */
    public void setId(Integer id) {
        this.id = id;
    }
 
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
 
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
}
PersonService.java
package cn.itcast.service;
 
import cn.itcast.bean.Person;
import java.util.List;
 
/**
 *
 * @author kang.cunhua
 */
public interface PersonService {
 
    /**
     * 保存person
     * @param person
     */
    public void save(Person person);
 
    /**
     * 更新person
     * @param person
     */
    public void update(Person person);
 
    /**
     * 获取person
     * @param personid
     * @return
     */
    public Person getPerson(Integer personid);
    /**
     * 获取所有person
     * @return
     */
    public List<Person> getPersons();
    /**
     * 删除指定id的person
     * @param personid
     */
    public void delete (Integer personid);
}
PersonServiceBean.java
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import java.util.List;
import javax.annotation.Resource;
import org.hibernate.SessionFactory;
import org.springframework.transaction.annotation.Propagation;
 
 
import org.springframework.transaction.annotation.Transactional;
 
/**
 *
 * @author kang.cunhua
 */
@Transactional
public class PersonServiceBean implements PersonService {
 
    @Resource
    private SessionFactory sessionFactory;
 
    @Override
    public void save(Person person) {
        sessionFactory.getCurrentSession().persist(person);
    }
 
    @Override
    public void update(Person person) {
        sessionFactory.getCurrentSession().merge(person);
    }
 
    @Override
    @Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)
    public Person getPerson(Integer personid) {
        return (Person) sessionFactory.getCurrentSession().get(Person.class, personid);
 
    }
 
    @Override
    @Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)
    public List<Person> getPersons() {
 
        return sessionFactory.getCurrentSession().createQuery("from Person").list();
    }
 
    @Override
    public void delete(Integer personid) {
        sessionFactory.getCurrentSession().delete(
                sessionFactory.getCurrentSession().load(Person.class, personid)
                );
    }
}
-------以上源码和上一讲一样---------
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    <!-- 配置Spring start -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:beans.xml</param-value>
    </context-param>
    <!-- 对Spring容器进行实例化 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 
 
    </listener>
    <!-- 配置Spring end -->
    <!-- 配置Struts start -->
    <servlet>
        <servlet-name>struts</servlet-name>
        <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
        <init-param>
            <param-name>config</param-name>
            <param-value>/WEB-INF/struts-config.xml</param-value>
        </init-param>
        <load-on-startup>0</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>struts</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    <!-- 配置Struts end -->
 
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>
struts-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
"http://struts.apache.org/dtds/struts-config_1_3.dtd">
 
<struts-config>
    <action-mappings>
        <action path="/person/list" type="cn.itcast.web.action.PersonAction" validate="false">
            <forward name="list" path="/WEB-INF/page/personlist.jsp" />
        </action>
    </action-mappings>
</struts-config>
PersonAction.java
package cn.itcast.web.action;
 
import cn.itcast.service.PersonService;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
 
/**
 *
 * @author kang.cunhua
 */
public class PersonAction extends Action {
 
    @Override
    public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
        WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(this.getServlet().getServletContext());
        PersonService personService = (PersonService) ctx.getBean("personService");
        request.setAttribute("persons", personService.getPersons());
        return mapping.findForward("list");
    }
 
}
personlist.jsp (/WEB-INF/page/personlist.jsp)
<%-- 
    Document : personlist
    Created on : 2010-8-5, 16:40:59
    Author : kang.cunhua
--%>
 
<%@page language="java" import="java.util.*" contentType="text/html" pageEncoding="UTF-8"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!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=UTF-8">
        <title>list</title>
    </head>
    <body>
        <h1>列出所有人的list!</h1>
        <c:forEach items="${persons}" var="person">
            ID=${person.id},name=${person.name}
        </c:forEach>
    </body>
</html>
首页：index.jsp
<%-- 
    Document : index
    Created on : 2010-7-31, 0:21:03
    Author : kang.cunhua
--%>
 
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!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=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <h1>Hello SSH's World!</h1>
        <a href="person/list.do">PersonList</a>
    </body>
</html>
题外话：
此处我如果给PersonServiceBean采用注解（@Resource）的方式注入sessionFaction的话（以上代码），就会报JMS错误，但不影响结果；
采用xml方式注入，就不会报错；
我采用环境的是JDK6+netbeans6.8+glassfish2；
报错如下：
deployed with moduleid = DemoSSH
NAM0006: 未找到 JMS 目标对象: cn.itcast.service.impl.PersonServiceBean/sessionFactory
javax.naming.NameNotFoundException
javax.naming.NameNotFoundException
        at com.sun.enterprise.naming.TransientContext.resolveContext(TransientContext.java:268)
        at com.sun.enterprise.naming.TransientContext.lookup(TransientContext.java:191)
        at com.sun.enterprise.naming.SerialContextProviderImpl.lookup(SerialContextProviderImpl.java:74)
        at com.sun.enterprise.naming.LocalSerialContextProviderImpl.lookup(LocalSerialContextProviderImpl.java:111)
        at com.sun.enterprise.naming.SerialContext.lookup(SerialContext.java:409)
        at javax.naming.InitialContext.lookup(InitialContext.java:392)
        at com.sun.enterprise.naming.NamingManagerImpl.bindObjects(NamingManagerImpl.java:391)
        at com.sun.enterprise.web.WebModuleContextConfig.configureResource(WebModuleContextConfig.java:228)
        at com.sun.enterprise.web.WebModuleContextConfig.lifecycleEvent(WebModuleContextConfig.java:164)
        at org.apache.catalina.util.LifecycleSupport.fireLifecycleEvent(LifecycleSupport.java:159)
        at org.apache.catalina.core.StandardContext.start(StandardContext.java:5276)
        at com.sun.enterprise.web.WebModule.start(WebModule.java:345)
        at org.apache.catalina.core.ContainerBase.addChildInternal(ContainerBase.java:986)
        at org.apache.catalina.core.ContainerBase.addChild(ContainerBase.java:970)
        at org.apache.catalina.core.StandardHost.addChild(StandardHost.java:704)
        at com.sun.enterprise.web.WebContainer.loadWebModule(WebContainer.java:1649)
        at com.sun.enterprise.web.WebContainer.loadWebModule(WebContainer.java:1254)
        at com.sun.enterprise.server.WebModuleDeployEventListener.moduleDeployed(WebModuleDeployEventListener.java:182)
        at com.sun.enterprise.server.WebModuleDeployEventListener.moduleDeployed(WebModuleDeployEventListener.java:278)
        at com.sun.enterprise.admin.event.AdminEventMulticaster.invokeModuleDeployEventListener(AdminEventMulticaster.java:1005)
        at com.sun.enterprise.admin.event.AdminEventMulticaster.handleModuleDeployEvent(AdminEventMulticaster.java:992)
        at com.sun.enterprise.admin.event.AdminEventMulticaster.processEvent(AdminEventMulticaster.java:470)
        at com.sun.enterprise.admin.event.AdminEventMulticaster.multicastEvent(AdminEventMulticaster.java:182)
        at com.sun.enterprise.admin.server.core.DeploymentNotificationHelper.multicastEvent(DeploymentNotificationHelper.java:308)
        at com.sun.enterprise.deployment.phasing.DeploymentServiceUtils.multicastEvent(DeploymentServiceUtils.java:231)
        at com.sun.enterprise.deployment.phasing.ServerDeploymentTarget.sendStartEvent(ServerDeploymentTarget.java:298)
        at com.sun.enterprise.deployment.phasing.ApplicationStartPhase.runPhase(ApplicationStartPhase.java:132)
        at com.sun.enterprise.deployment.phasing.DeploymentPhase.executePhase(DeploymentPhase.java:108)
        at com.sun.enterprise.deployment.phasing.PEDeploymentService.executePhases(PEDeploymentService.java:966)
        at com.sun.enterprise.deployment.phasing.PEDeploymentService.start(PEDeploymentService.java:609)
        at com.sun.enterprise.deployment.phasing.PEDeploymentService.start(PEDeploymentService.java:653)
        at com.sun.enterprise.admin.mbeans.ApplicationsConfigMBean.start(ApplicationsConfigMBean.java:773)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
        at java.lang.reflect.Method.invoke(Method.java:597)
        at com.sun.enterprise.admin.MBeanHelper.invokeOperationInBean(MBeanHelper.java:390)
        at com.sun.enterprise.admin.MBeanHelper.invokeOperationInBean(MBeanHelper.java:373)
        at com.sun.enterprise.admin.config.BaseConfigMBean.invoke(BaseConfigMBean.java:477)
        at com.sun.jmx.interceptor.DefaultMBeanServerInterceptor.invoke(DefaultMBeanServerInterceptor.java:836)
        at com.sun.jmx.mbeanserver.JmxMBeanServer.invoke(JmxMBeanServer.java:761)
        at sun.reflect.GeneratedMethodAccessor13.invoke(Unknown Source)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
        at java.lang.reflect.Method.invoke(Method.java:597)
        at com.sun.enterprise.admin.util.proxy.ProxyClass.invoke(ProxyClass.java:90)
        at $Proxy1.invoke(Unknown Source)
        at com.sun.enterprise.admin.server.core.jmx.SunoneInterceptor.invoke(SunoneInterceptor.java:304)
        at com.sun.enterprise.interceptor.DynamicInterceptor.invoke(DynamicInterceptor.java:170)
        at com.sun.enterprise.admin.jmx.remote.server.callers.InvokeCaller.call(InvokeCaller.java:69)
        at com.sun.enterprise.admin.jmx.remote.server.MBeanServerRequestHandler.handle(MBeanServerRequestHandler.java:155)
        at com.sun.enterprise.admin.jmx.remote.server.servlet.RemoteJmxConnectorServlet.processRequest(RemoteJmxConnectorServlet.java:122)
        at com.sun.enterprise.admin.jmx.remote.server.servlet.RemoteJmxConnectorServlet.doPost(RemoteJmxConnectorServlet.java:193)
        at javax.servlet.http.HttpServlet.service(HttpServlet.java:754)
        at javax.servlet.http.HttpServlet.service(HttpServlet.java:847)
        at org.apache.catalina.core.ApplicationFilterChain.servletService(ApplicationFilterChain.java:427)
        at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:315)
        at org.apache.catalina.core.StandardContextValve.invokeInternal(StandardContextValve.java:287)
        at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:218)
        at org.apache.catalina.core.StandardPipeline.doInvoke(StandardPipeline.java:648)
        at org.apache.catalina.core.StandardPipeline.doInvoke(StandardPipeline.java:593)
        at com.sun.enterprise.web.WebPipeline.invoke(WebPipeline.java:94)
        at com.sun.enterprise.web.PESessionLockingStandardPipeline.invoke(PESessionLockingStandardPipeline.java:98)
        at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:222)
        at org.apache.catalina.core.StandardPipeline.doInvoke(StandardPipeline.java:648)
        at org.apache.catalina.core.StandardPipeline.doInvoke(StandardPipeline.java:593)
        at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:587)
        at org.apache.catalina.core.ContainerBase.invoke(ContainerBase.java:1093)
        at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:166)
        at org.apache.catalina.core.StandardPipeline.doInvoke(StandardPipeline.java:648)
        at org.apache.catalina.core.StandardPipeline.doInvoke(StandardPipeline.java:593)
        at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:587)
        at org.apache.catalina.core.ContainerBase.invoke(ContainerBase.java:1093)
        at org.apache.coyote.tomcat5.CoyoteAdapter.service(CoyoteAdapter.java:291)
        at com.sun.enterprise.web.connector.grizzly.DefaultProcessorTask.invokeAdapter(DefaultProcessorTask.java:666)
        at com.sun.enterprise.web.connector.grizzly.DefaultProcessorTask.doProcess(DefaultProcessorTask.java:597)
        at com.sun.enterprise.web.connector.grizzly.DefaultProcessorTask.process(DefaultProcessorTask.java:872)
        at com.sun.enterprise.web.connector.grizzly.DefaultReadTask.executeProcessorTask(DefaultReadTask.java:341)
        at com.sun.enterprise.web.connector.grizzly.DefaultReadTask.doTask(DefaultReadTask.java:263)
        at com.sun.enterprise.web.connector.grizzly.DefaultReadTask.doTask(DefaultReadTask.java:214)
        at com.sun.enterprise.web.connector.grizzly.TaskBase.run(TaskBase.java:264)
        at com.sun.enterprise.web.connector.grizzly.WorkerThreadImpl.run(WorkerThreadImpl.java:117)
log4j:WARN No appenders could be found for logger (org.springframework.core.CollectionFactory).
log4j:WARN Please initialize the log4j system properly.
PWC1412：WebModule[/DemoSSH] ServletContext.log():Initializing Spring root WebApplicationContext
xml方式注入：
xml文件：beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${driverClassName}" />
        <property name="url" value="${url}" />
        <property name="username" value="${username}" />
        <property name="password" value="${password}"/>
        <!-- 连接池启动时的初始值 -->
        <property name="initialSize" value="${initialSize}" />
        <!-- 连接池的最大值 -->
        <property name="maxActive" value="${maxActive}"/>
        <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
        <property name="maxIdle" value="${maxIdle}"/>
        <!-- 最小空闲值，当空闲的连接数少于阀值时，连接池就会去申请一些连接，以免洪峰来时来不及申请 -->
        <property name="minIdle" value="${minIdle}" />
    </bean>
    <bean id = "sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="mappingResources">
            <list>
                <value>cn/itcast/bean/Person.hbm.xml</value> <!-- 可以有多个Hibernate实体bean的映射文件 -->
            </list>
        </property>
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
                hibernate.hbm2ddl.auto=update
                hibernate.show_sql=false
                hibernate.format_sql=false
            </value>
        </property>
    </bean>
    <!-- Spring 针对Hibernate提供的事务管理器 -->
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean" >
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <bean id="personList" class="cn.itcast.web.action.PersonAction"/>
    <!-- 采用注解的方式进行事务声明 -->
    <tx:annotation-driven transaction-manager="txManager"/>
    <context:annotation-config/>
 
</beans>
PersonServiceBean.java
 
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import java.util.List;
import org.hibernate.SessionFactory;
import org.springframework.transaction.annotation.Propagation;
 
 
import org.springframework.transaction.annotation.Transactional;
 
/**
 *
 * @author kang.cunhua
 */
@Transactional
public class PersonServiceBean implements PersonService {
 
 
    private SessionFactory sessionFactory;
 
    @Override
    public void save(Person person) {
        getSessionFactory().getCurrentSession().persist(person);
    }
 
    @Override
    public void update(Person person) {
        getSessionFactory().getCurrentSession().merge(person);
    }
 
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public Person getPerson(Integer personid) {
        return (Person) getSessionFactory().getCurrentSession().get(Person.class, personid);
 
    }
 
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public List<Person> getPersons() {
 
        return getSessionFactory().getCurrentSession().createQuery("from Person").list();
    }
 
    @Override
    public void delete(Integer personid) {
        getSessionFactory().getCurrentSession().delete(
                getSessionFactory().getCurrentSession().load(Person.class, personid));
    }
 
    /**
     * @return the sessionFactory
     */
    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }
 
    /**
     * @param sessionFactory the sessionFactory to set
     */
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
}
]]> http://www.guloulou.com/?feed=rss2&p=1991 0 26_传智播客Spring2.5视频教程_Spring集成的Hibernate编码与测试 http://www.guloulou.com/?p=1985 http://www.guloulou.com/?p=1985#comments Wed, 04 Aug 2010 18:42:09 +0000 guloulou http://www.guloulou.com/?p=1985 26_传智播客Spring2.5视频教程_Spring集成的Hibernate编码与测试
 
开发完业务方法，一定要进行单元测试；
junit4中setUpBeforeClass()方法是可以在单元测试实例被构建出来之后，就先执行的方法。我们可以在这个方法中做一些初始化操作；
 
实体bean必须要保留默认构造函数（没有参数的）；
bean.xml中配置 hibernate.hbm2ddl.auto=update 可以根据配置的元数据自动生成表
--------
单元测试后，确定业务层没有问题，就可以进行struts的集成了；
------------
强烈建议有兴趣的童鞋自行对照视频学习；个人笔力所限，不能尽显黎活明老师所讲解的开发思想；个人学习这套视频受益匪浅！
给出源码：
beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${driverClassName}" />
        <property name="url" value="${url}" />
        <property name="username" value="${username}" />
        <property name="password" value="${password}"/>
        <!-- 连接池启动时的初始值 -->
        <property name="initialSize" value="${initialSize}" />
        <!-- 连接池的最大值 -->
        <property name="maxActive" value="${maxActive}"/>
        <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
        <property name="maxIdle" value="${maxIdle}"/>
        <!-- 最小空闲值，当空闲的连接数少于阀值时，连接池就会去申请一些连接，以免洪峰来时来不及申请 -->
        <property name="minIdle" value="${minIdle}" />
    </bean>
    <bean id = "sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="mappingResources">
            <list>
                <value>cn/itcast/bean/Person.hbm.xml</value> <!-- 可以有多个Hibernate实体bean的映射文件 -->
            </list>
        </property>
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
                hibernate.hbm2ddl.auto=update
                hibernate.show_sql=false
                hibernate.format_sql=false
            </value>
        </property>
    </bean>
    <!-- Spring 针对Hibernate提供的事务管理器 -->
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean" />
    <!-- 采用注解的方式进行事务声明 -->
    <tx:annotation-driven transaction-manager="txManager"/>
    <context:annotation-config/>
 
</beans>
jdbc.properties
# To change this template, choose Tools | Templates
# and open the template in the editor.
driverClassName =org.gjt.mm.mysql.Driver
url=jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8
username=root
password=
initialSize =1
maxActive=500
maxIdle=2
minIdle=1
Person.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
 
<!--
    Document : Person.hbm.xml
    Created on : 2010年7月31日, 上午1:42
    Author : kang.cunhua
    Description:
        Purpose of the document follows.
-->
 
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.bean">
    <class name="Person" table="person">
        <id name="id" type="integer">
            <generator class="native"/>
        </id>
        <property name="name" length="10" not-null="true"/>
    </class>
</hibernate-mapping>
Person.java
package cn.itcast.bean;
 
/**
 *
 * @author kang.cunhua
 */
public class Person {
 
    private Integer id;
    private String name;
 
    public Person() {
    }
 
    public Person(String name) {
 
        this.name = name;
    }
 
    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
 
    /**
     * @return the id
     */
    public Integer getId() {
        return id;
    }
 
    /**
     * @param id the id to set
     */
    public void setId(Integer id) {
        this.id = id;
    }
 
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
 
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
}
PersonService.java
package cn.itcast.service;
 
import cn.itcast.bean.Person;
import java.util.List;
 
/**
 *
 * @author kang.cunhua
 */
public interface PersonService {
 
    /**
     * 保存person
     * @param person
     */
    public void save(Person person);
 
    /**
     * 更新person
     * @param person
     */
    public void update(Person person);
 
    /**
     * 获取person
     * @param personid
     * @return
     */
    public Person getPerson(Integer personid);
    /**
     * 获取所有person
     * @return
     */
    public List<Person> getPersons();
    /**
     * 删除指定id的person
     * @param personid
     */
    public void delete (Integer personid);
}
PersonServiceBean.java
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import java.util.List;
import javax.annotation.Resource;
import org.hibernate.SessionFactory;
import org.springframework.transaction.annotation.Propagation;
 
 
import org.springframework.transaction.annotation.Transactional;
 
/**
 *
 * @author kang.cunhua
 */
@Transactional
public class PersonServiceBean implements PersonService {
 
    @Resource
    private SessionFactory sessionFactory;
 
    @Override
    public void save(Person person) {
        sessionFactory.getCurrentSession().persist(person);
    }
 
    @Override
    public void update(Person person) {
        sessionFactory.getCurrentSession().merge(person);
    }
 
    @Override
    @Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)
    public Person getPerson(Integer personid) {
        return (Person) sessionFactory.getCurrentSession().get(Person.class, personid);
 
    }
 
    @Override
    @Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)
    public List<Person> getPersons() {
 
        return sessionFactory.getCurrentSession().createQuery("from Person").list();
    }
 
    @Override
    public void delete(Integer personid) {
        sessionFactory.getCurrentSession().delete(
                sessionFactory.getCurrentSession().load(Person.class, personid)
                );
    }
}
单元测试：
PersonServiceBeanTest.java
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import java.util.List;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
/**
 *
 * @author kang.cunhua
 */
public class PersonServiceBeanTest {
    private static PersonService personService;
 
    public PersonServiceBeanTest() {
    }
 
    @BeforeClass
    public static void setUpClass() throws Exception {
        try {
            ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
            personService = (PersonService) cxt.getBean("personService");
        } catch (BeansException beansException) {
            beansException.printStackTrace();
        }
    }
 
    @AfterClass
    public static void tearDownClass() throws Exception {
    }
 
    @Before
    public void setUp() {
    }
 
    @After
    public void tearDown() {
    }
 
    /**
     * Test of save method, of class PersonServiceBean.
     */
    @Test
    public void testSave() {
        System.out.println("save");
        personService.save(new Person("小张"));
 
    }
 
    /**
     * Test of update method, of class PersonServiceBean.
     */
    @Test
    public void testUpdate() {
        System.out.println("update");
        Person person = personService.getPerson(1);
        person.setName("小丽");
        personService.update(person);
 
 
    }
 
    /**
     * Test of getPerson method, of class PersonServiceBean.
     */
    @Test
    public void testGetPerson() {
        System.out.println("getPerson");
        Person person = personService.getPerson(1);
        System.out.println("person:" + person.getName());
 
    }
 
    /**
     * Test of getPersons method, of class PersonServiceBean.
     */
    @Test
    public void testGetPersons() {
        System.out.println("getPersons");
        List <Person> persons = personService.getPersons();
        for(Person person:persons){
            System.out.println("person:" + person.getName());
        }
 
    }
 
    /**
     * Test of delete method, of class PersonServiceBean.
     */
    @Test
    public void testDelete() {
        personService.delete(1);
        System.out.println("delete");
 
    }
 
}

]]> http://www.guloulou.com/?feed=rss2&p=1985 0 25_传智播客Spring2.5视频教程_搭建和配置Spring与Hibernate整合的环境 http://www.guloulou.com/?p=1984 http://www.guloulou.com/?p=1984#comments Wed, 04 Aug 2010 18:41:56 +0000 guloulou http://www.guloulou.com/?p=1984 25_传智播客Spring2.5视频教程_搭建和配置Spring与Hibernate整合的环境
Spring2.5+Hibernate3.3+Struts1.3整合开发
Hibernate核心安装包下的：
hibernate3.jar
lib\required\*.jar
lib\optional\ehcache-1.2.3.jar
Hibernage注解安装包下的：
lib\test\slf4j-log4j12.jar
Spring安装包下的：
dist\spring.jar
dist\modules\spring-webmvc-struts.jar
lib\jakarta-commons\commons-logging.jar、commons-dbcp.jar、commons-pool.jar
lib\aspectj\aspectjweaver.jar、aspectjrt.jar
lib\cglib\cglib-nodep-2.1_3.jar
lib\j2ee\common-annotations.jar
lib\log4j\log4j-1.2.15.jar
Struts
下载struts-1.3.8-lib.zip,需要使用到解压目录下的所有jar，建议把jstl-1.0.2.jar和standard-1.0.2.jar更换为1.1版本。Spring中已经存在一个antlr-2.7.6.jar，所以把struts中的antlr-2.7.2.jar删除，避免jar冲突；
数据库驱动jar
建议：
分步整合，先整合Spring+Hibernate，然后再整合Struts；
我们在整合Spring和Hibernate时，需要将sessionFaction交给Spring管理；
------------------
网摘：
在Hibernate的设计者的头脑中，他们将session看作介于数据连接与事务管理一种中间接口。我们可以将session想象成一个持久对象的缓冲区，Hibernate能检测到这些持久对象的改变，并及时刷新数据库。我们有时也称Session是一个持久层管理器，因为它包含这一些持久层相关的操作，诸如存储持久对象至数据库，以及从数据库从获得它们。
Hibernate   的session不同于JSP应用中的HttpSession。当我们使用session这个术语时，我们指的是Hibernate中的session，而我们以后会将HttpSesion对象称为用户session。
------------------
Hibernate二级缓存的配置
<bean id = "sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="mappingResources">
        <list>
            <value>cn/itcast/bean/Person.hbm.xml</value>
        </list>
    </property>
    <property name="hibernateProperties">
        <value>
            hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
            hibernate.hbm2ddl.auto=update
            hibernate.show_sql=false
            hibernate.format_sql=false
            hibernate.cache.use_second_level_cache=true
            hibernate.cache.use_query_cache=false
            hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
        </value>
    </property>
</bean>
-------------------
Hibernate实体Bean模板
<?xml version="1.0" encoding="UTF-8"?>
 
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.bean">
    <class name="Person" table="person">
        <id name="id" type="integer">
            <generator class="native"/>
        </id>
        <property name="name" length="10" not-null="true"/>
    </class>
</hibernate-mapping>
-----------------------
通过Spring使用sessionFaction
接下来，我们要做 在业务层（DAO，视频中DAO层和Service层合并在一起了，实际开发中并不推荐这么做），怎么通过Spring使用sessionFaction；
    <bean id = "sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="mappingResources">
            <list>
                <value>cn/itcast/bean/Person.hbm.xml</value> <!-- 可以有多个Hibernate实体bean的映射文件 -->
            </list>
        </property>
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=org.hibernate.diaect.MySQL5Dialect
                hibernate.hbm2ddl.auto=update
                hibernate.show_sql=false
                hibernate.format_sql=false
            </value>
        </property>
    </bean>
    <!-- Spring 针对Hibernate提供的事务管理器 -->
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <!-- 采用注解的方式进行事务声明 -->
    <tx:annotation-driven transaction-manager="txManager"/>
    <context:annotation-config/>
心得：
这一讲主要讲解Spring和Hibernate集成时环境搭建；下一讲会做一些编码测试；再接下来会是Struts的集成；
黎活明老师讲解的整合思路，也是我们需要学习的实际项目开发应遵循的一些顺序：先业务层，再单元测试；最后显示层；
一步步的集成讲解也是让我们能够掌握集成的原理；再碰上其他框架集成时的一些方法技巧；
下一讲给出整合Spring和Hibernate的测试编码；
 
 

]]> http://www.guloulou.com/?feed=rss2&p=1984 0 24_传智播客Spring2.5视频教程_使用Spring配置文件实现事务管理 http://www.guloulou.com/?p=1981 http://www.guloulou.com/?p=1981#comments Fri, 30 Jul 2010 06:29:35 +0000 guloulou http://www.guloulou.com/?p=1981 24_传智播客Spring2.5视频教程_使用Spring配置文件实现事务管理
采用基于XML方式配置事务
<bean id="txManager" class="org.springframework.jdbc.datasourceTransactionManager">
    <property name="dataSource" ref="dataSource">
</bean>
<aop:config>
    <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))" />
    <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut" />
</aop:config>
<tx:advice id="txAdvice" transaction-manager="txManager">
    <tx:attributes>
        <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED" />
        <tx:method name="*" />
    </tx:attributes>
</tx:advice>
-----------------------
上一讲说的是使用注解的方式来管理事务，这一讲讲解采用配置文件的方式管理事务
在切入点定义事务通知：<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut" />
为所有查询方法指定只读且不需要事务管理<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED" />
其他的，看代码吧。easy的；
上代码：
beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${driverClassName}" />
        <property name="url" value="${url}" />
        <property name="username" value="${username}" />
        <property name="password" value="${password}"/>
        <!-- 连接池启动时的初始值 -->
        <property name="initialSize" value="${initialSize}" />
        <!-- 连接池的最大值 -->
        <property name="maxActive" value="${maxActive}"/>
        <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
        <property name="maxIdle" value="${maxIdle}"/>
        <!-- 最小空闲值，当空闲的连接数少于阀值时，连接池就会去申请一些连接，以免洪峰来时来不及申请 -->
        <property name="minIdle" value="${minIdle}" />
 
    </bean>
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 采用@Transactional注解方式使用事务 -->
    <tx:annotation-driven transaction-manager="txManager" />
    <aop:config>
        <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut" />
    </aop:config>
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED" />
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice>
 
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean" >
        <property name="dataSource" ref="dataSource"></property>
    </bean>
 
</beans>
PersonServiceBean.java
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;
 
/**
 *
 * @author kang.cunhua
 */
 
public class PersonServiceBean implements PersonService {
 
    private JdbcTemplate jdbcTemplate;
 
    @Override
    public void save(Person person) {
        System.out.println("俺是save(Person person)方法！");
        jdbcTemplate.update("insert into person(name) values(?)",
                new Object[]{person.getName()},
                new int[]{java.sql.Types.VARCHAR});
 
    }
 
    @Override
    public void update(Person person) {
        System.out.println("俺是update(Person person)方法！");
        jdbcTemplate.update("update person set name=? where id=?",
                new Object[]{person.getName(), person.getId()},
                new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});
 
    }
 
    @Override
    public Person getPerson(Integer personid) {
        System.out.println("俺是getPerson(Integer personid)方法！");
        return (Person) jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid},
                new int[]{java.sql.Types.INTEGER},
                new PersonRowMapper());
    }
 
    @Override
    public List<Person> getPersons() {
        System.out.println("俺是getPersons()方法！");
        return (List<Person>) jdbcTemplate.query("select * from person", new PersonRowMapper());
    }
 
    @Override
    public void delete(Integer personid) {
        System.out.println("俺是delete(Integer personid)方法！");
        jdbcTemplate.update("delete from person where id=?",
                new Object[]{personid},
                new int[]{java.sql.Types.INTEGER});
        jdbcTemplate.update("delete from personss where id=10"); // 此处故意写错表名，测试两个方法是否在同一个事务中执行
        // throw new RuntimeException("运行期例外"); // 抛出运行期例外，测试事务回滚！
    }
 
    /**
     * @param dataSource the dataSource to set
     */
    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }
}
PersonServiceBeanTest.java
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
/**
 *
 * @author kang.cunhua
 */
public class PersonServiceBeanTest {
 
    private static PersonService personService;
 
    public PersonServiceBeanTest() {
    }
 
    @BeforeClass
    public static void setUpClass() throws Exception {
        ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
        personService = (PersonService) cxt.getBean("personService");
    }
 
    @AfterClass
    public static void tearDownClass() throws Exception {
    }
 
    @Before
    public void setUp() {
    }
 
    /**
     * Test of save method, of class PersonServiceBean.
     */
    @Test
    public void testSave() {
        for (int i = 10; i < 15; i++) {
            personService.save(new Person("传智播客" + i));
        }
 
    }
 
    /**
     * Test of getPerson method, of class PersonServiceBean.
     */
    @Test
    public void testGetPerson() {
        Person person = personService.getPerson(2);
        System.out.println(" testGetPerson() ：" + person.getName());
    }
 
    /**
     * Test of update method, of class PersonServiceBean.
     */
    @Test
    public void testUpdate() {
        Person person = personService.getPerson(2);
        person.setName("张**");
        personService.update(person);
 
    }
 
    /**
     * Test of getPersons method, of class PersonServiceBean.
     */
    @Test
    public void testGetPersons() {
        for (Person person:personService.getPersons()) {
            System.out.println("testGetPersons():" + person.getName());
        }
    }
 
    /**
     * Test of delete method, of class PersonServiceBean.
     */
    @Test
    public void testDelete() {
        personService.delete(7);
    }
}
注：其余代码和前两讲一样；

]]> http://www.guloulou.com/?feed=rss2&p=1981 0 23_传智播客Spring2.5视频教程_使用Spring注解方式管理事务与传播行为详解 http://www.guloulou.com/?p=1978 http://www.guloulou.com/?p=1978#comments Thu, 29 Jul 2010 15:39:34 +0000 guloulou http://www.guloulou.com/?p=1978 23_传智播客Spring2.5视频教程_使用Spring注解方式管理事务与传播行为详解
前面讲解到使用@Transactionl对业务方法进行事务管理；执行业务方法前打开事务，执行完毕后关闭事务；那么，
Q：Spring什么时候决定事务提交，什么时候决定事务回滚（失败）呢？
A：Spring默认时对运行期例外回滚，对用户例外（比如check）不回滚；
check例外，一个方法抛出的例外需要调用者捕获的话，就是check例外；
一个方法抛出的例外，不需要调用者捕获的话，就是非check例外；如运行期例外；
---------------
运行期例外 // unchecked；默认回滚
Service层代码：
public void delete( Integer personid ){
    jdbcTemplate.update("delete from person where id=?", new Object[]{personid} ,
    new int[] {java.sql.Types.INTEGER});    
    throw new RuntimeException("运行期例外");

}

此时单元测试时调用是不需要check该异常的
@Test public void delete(){
    personService.delete(6);
}
 
需要check的例外 // checked； 默认不回滚
Service层代码： 
public void delete( Integer personid ) throws Exception{
    jdbcTemplate.update("delete from person where id=?", new Object[]{personid} ,
    new int[] {java.sql.Types.INTEGER});    
    throw new Exception("非运行期例外");

}

单元测试如下：
@Test public void delete(){
    try{
        personService.delete(6);
    }catch (Exception e){
        e.printStackTrace();
    }
}
如果需要check的例外需要回滚，则需要设置@Transactional参数
@Transactional ( rollbackFor=Exception.class )
public void delete( Integer personid ) throws Exception{
    jdbcTemplate.update("delete from person where id=?", new Object[]{personid} ,
    new int[] {java.sql.Types.INTEGER});    
    throw new Exception("非运行期例外");

}

当某个方法不需要事务是怎么处理？
比如，getPerson(Integer personid)方法就不需要开启事务。开启事务是需要消耗性能的；
这时，我们需要是使用@Transactional(propagation=Propagation.NOT_SUPPORTED)来指明该方法不需要事务处理；NOT_SUPPORTED为事务传播属性；
事务传播属性
REQUIRED:业务方法需要在一个事务中运行，如果方法运行时已经处在一个事务中，那么如何加入到该事务，否则为自己创建一个新事务；// 默认80%都是这种事务传播行为；
NOT_SUPPORTED:声明方法不需要事务，如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。
REQUIRESNEW:属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起，新的事务会被创建，知道方法执行结束，新事务才算结束，原先的事务才会恢复执行。
MANDATORY:该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，容器就会抛出例外。
SUPPORTS:这一事务属性表明，如果业务方法在某个事物范围内被调用，则方法称为该事务的一部分。如果业务方法在事务范围外被调用，则方法在某有事务的环境下执行。
Never:执行业务方法绝对不能在事务范围内执行。如果业务方法在某个事物中执行，容器会抛出例外，只有业务方法没有关联到任何事务，才能正常执行。
NESTED:如果一个活动的事务存在，则运行在一个嵌套的事务中。如果没有活动事务，则按REQUIRED属性执行，它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效；
另，
前几种REQUIRED，NOT_SUPPORTED，REQUIRESNEW，MANDATORY，SUPPORTS，Never在EJB中也有体现（Spring借鉴EJB的地方）；最后一种NESTED为Spring独有；
----------------
事务传播属性NESTED介绍
@Resource OtherService otherService;
public void xxx(){
    stmt.executeUpdate("update person set name='888' where id = 1");
    otherService.update();// OtherService的update方法的事务传播属性为NESTED
    stmt.executeUpdate("delete from person where id = 9");
}
上面的xxx()方法事务在内部执行的过程
Connection conn = null;
try {
    conn.setAutoCommit(false);
    Statement stmt = conn.createStatement();
    stmt.executeUpdate("update person set name = '888' where id = 1");
    Savepoint savepoint = conn.setSavepoint();
    try{
        conn.createStatement().executeUpdate("update person set name = '222' where sid = 2");
    }catch(Exception ex){
        conn.rollback(savepoint);
    }
    stmt.executeUpdate("delete from person where id = 9");
    conn.commit();
    stmt.close();
}catch (Exception e){
    conn.rollback();
}finally{
    try{
        if(null != conn && !conn.isClosed()) conn.close();
    }catch( SQLException e){
        e.printStackTrace();
    }
}
总结：
内部事务不会影响到外部事物的结果；
但外部事务如果失败，内部事务同样也要回滚；
----------------
数据库系统提供了四种事务隔离级别
数据库系统提供了四种事务隔离级别供用户选择。不同的隔离级别采用不同的锁类型来实现，在四种隔离级别中，Serializable的隔离级别最高，Read Uncommited的隔离级别最低。大多数据库默认的隔离界别为Read Commited，如SQL Server 2000，当然也有少部分数据库默认的隔离级别为Repeatable Read，如Mysql；SQL Server 2005提供了默认的Read Commited的隔离级别，当然也通过快照技术提供了Repeatable Read隔离级别（推荐使用后者）的支持;
  • Read Uncommited：读未提交数据（会出现脏读，不可重复读和幻读）；
  • Read Commited：读提交数据（会出现不可重复读和幻读）；
  • Repeatable Read：可重复读（会出现幻读）
  • Serializable：串行化
脏读：一个事务读取到另一个事务未提交的更新数据；
不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。换句话说就是，后续读取可以读到另一事务已经提交的更新数据。相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取不能读到另一事务已经提交的更新数据。
----------------
快照技术实现可重复读
----------------
代码：
创建表：person.sql
/*
Navicat MySQL Data Transfer
 
Source Server : localhost
Source Server Version : 50133
Source Host : localhost:3306
Source Database : itcast
 
Target Server Type : MYSQL
Target Server Version : 50133
File Encoding : 65001
 
Date: 2010-07-23 15:54:58
*/
 
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for `person`
-- ----------------------------
DROP TABLE IF EXISTS `person`;
CREATE TABLE `person` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-- ----------------------------
-- Records of person
-- ----------------------------
PersonServiceBean.java
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;
 
/**
 *
 * @author kang.cunhua
 */
@Transactional
public class PersonServiceBean implements PersonService {
 
    private JdbcTemplate jdbcTemplate;
 
    @Override
    public void save(Person person) {
        System.out.println("俺是save(Person person)方法！");
        jdbcTemplate.update("insert into person(name) values(?)",
                new Object[]{person.getName()},
                new int[]{java.sql.Types.VARCHAR});
 
    }
 
    @Override
    public void update(Person person) {
        System.out.println("俺是update(Person person)方法！");
        jdbcTemplate.update("update person set name=? where id=?",
                new Object[]{person.getName(), person.getId()},
                new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});
 
    }
 
    @Override
    public Person getPerson(Integer personid) {
        System.out.println("俺是getPerson(Integer personid)方法！");
        return (Person) jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid},
                new int[]{java.sql.Types.INTEGER},
                new PersonRowMapper());
    }
 
    @Override
    public List<Person> getPersons() {
        System.out.println("俺是getPersons()方法！");
        return (List<Person>) jdbcTemplate.query("select * from person", new PersonRowMapper());
    }
 
    @Override
    public void delete(Integer personid) {
        System.out.println("俺是delete(Integer personid)方法！");
        jdbcTemplate.update("delete from person where id=?",
                new Object[]{personid},
                new int[]{java.sql.Types.INTEGER});
        throw new RuntimeException("运行期例外"); // 抛出运行期例外，测试事务回滚！
    }
 
    /**
     * @param dataSource the dataSource to set
     */
    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }
}
PersonServiceBeanTest.java
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
/**
 *
 * @author kang.cunhua
 */
public class PersonServiceBeanTest {
 
    private static PersonService personService;
 
    public PersonServiceBeanTest() {
    }
 
    @BeforeClass
    public static void setUpClass() throws Exception {
        ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
        personService = (PersonService) cxt.getBean("personService");
    }
 
    @AfterClass
    public static void tearDownClass() throws Exception {
    }
 
    @Before
    public void setUp() {
    }
 
    /**
     * Test of save method, of class PersonServiceBean.
     */
    @Test
    public void testSave() {
        for (int i = 0; i < 5; i++) {
            personService.save(new Person("传智播客" + i));
        }
 
    }
 
    /**
     * Test of getPerson method, of class PersonServiceBean.
     */
    @Test
    public void testGetPerson() {
        Person person = personService.getPerson(2);
        System.out.println(" testGetPerson() ：" + person.getName());
    }
 
    /**
     * Test of update method, of class PersonServiceBean.
     */
    @Test
    public void testUpdate() {
        Person person = personService.getPerson(2);
        person.setName("张**");
        personService.update(person);
 
    }
 
    /**
     * Test of getPersons method, of class PersonServiceBean.
     */
    @Test
    public void testGetPersons() {
        for (Person person:personService.getPersons()) {
            System.out.println("testGetPersons():" + person.getName());
        }
    }
 
    /**
     * Test of delete method, of class PersonServiceBean.
     */
    @Test
    public void testDelete() {
        personService.delete(5);
    }
}
另，代码变动不大。其余代码和上一讲一样。主要是事务理念的理解。为今后的应用打下基础。
 

]]> http://www.guloulou.com/?feed=rss2&p=1978 1 22_传智播客Spring2.5视频教程_Spring集成的jdbc编码和事务管理 http://www.guloulou.com/?p=1974 http://www.guloulou.com/?p=1974#comments Mon, 26 Jul 2010 06:46:45 +0000 guloulou http://www.guloulou.com/?p=1974 22_传智播客Spring2.5视频教程_Spring集成的jdbc编码和事务管理
使用Spring的JdbcTemplate完善JDBC数据库CRUD
private JdbcTemplate jdbcTemplate;
    /**
     * @param dataSource the dataSource to set
     */
    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }
..............
@Override
    public void save(Person person) {
        System.out.println("俺是save(Person person)方法！");
        jdbcTemplate.update("insert into person(name) values(?)",
                new Object[]{person.getName()},
                new int[]{java.sql.Types.VARCHAR});

 

    }

.................

@Override
    public Person getPerson(Integer personid) {
        System.out.println("俺是getPerson(Integer personid)方法！");
        return (Person) jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid},
                new int[]{java.sql.Types.INTEGER},
                new PersonRowMapper());
    }

getPerson(Integer personid)使用到RowMapper接口
public class PersonRowMapper implements RowMapper {
 
    @Override
    public Object mapRow(ResultSet rs, int i) throws SQLException {
        Person person = new Person(rs.getString("name"));
        person.setId(rs.getInt("id"));
        return person;
    }
}
spring提供的事务注解
如果不是用spring提供的事务注解，默认情况下，业务bean中的方法每条sql都是在各自独立的事务中执行的；
使用@Transactional的话，在调用方法业务bean中方法前会打开事务，在调用后会关闭事务。确保业务bean中方法内部是在一个事务中执行的；// 这些设定在实际开发中 会很有用的。
保留表结构，清楚所有数据：
TRUNCATE TABLE person
上代码：
beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${driverClassName}" />
        <property name="url" value="${url}" />
        <property name="username" value="${username}" />
        <property name="password" value="${password}"/>
        <!-- 连接池启动时的初始值 -->
        <property name="initialSize" value="${initialSize}" />
        <!-- 连接池的最大值 -->
        <property name="maxActive" value="${maxActive}"/>
        <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
        <property name="maxIdle" value="${maxIdle}"/>
        <!-- 最小空闲值，当空闲的连接数少于阀值时，连接池就会去申请一些连接，以免洪峰来时来不及申请 -->
        <property name="minIdle" value="${minIdle}" />
 
    </bean>
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 采用@Transactional注解方式使用事务 -->
    <tx:annotation-driven transaction-manager="txManager" />
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean" >
        <property name="dataSource" ref="dataSource"></property>
    </bean>
 
</beans>
jdbc.properties
# To change this template, choose Tools | Templates
# and open the template in the editor.
driverClassName =org.gjt.mm.mysql.Driver
url=jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8
username=root
password=
initialSize =1
maxActive=500
maxIdle=2
minIdle=1
Person.java
package cn.itcast.bean;
 
/**
 *
 * @author kang.cunhua
 */
public class Person {
 
    private Integer id;
    private String name;
 
    public Person() {
    }
 
    public Person(String name) {
 
        this.name = name;
    }
 
    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
 
    /**
     * @return the id
     */
    public Integer getId() {
        return id;
    }
 
    /**
     * @param id the id to set
     */
    public void setId(Integer id) {
        this.id = id;
    }
 
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
 
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
}
PersonService.java
package cn.itcast.service;
 
import cn.itcast.bean.Person;
import java.util.List;
 
/**
 *
 * @author kang.cunhua
 */
public interface PersonService {
 
    /**
     * 保存person
     * @param person
     */
    public void save(Person person);
 
    /**
     * 更新person
     * @param person
     */
    public void update(Person person);
 
    /**
     * 获取person
     * @param personid
     * @return
     */
    public Person getPerson(Integer personid);
    /**
     * 获取所有person
     * @return
     */
    public List<Person> getPersons();
    /**
     * 删除指定id的person
     * @param personid
     */
    public void delete (Integer personid);
}
PersonRowMapper.java
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
 
/**
 *
 * @author kang.cunhua
 */
public class PersonRowMapper implements RowMapper {
 
    @Override
    public Object mapRow(ResultSet rs, int i) throws SQLException {
        Person person = new Person(rs.getString("name"));
        person.setId(rs.getInt("id"));
        return person;
    }
}
PersonServiceBean.java
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;
 
/**
 *
 * @author kang.cunhua
 */
@Transactional
public class PersonServiceBean implements PersonService {
 
    private JdbcTemplate jdbcTemplate;
 
    @Override
    public void save(Person person) {
        System.out.println("俺是save(Person person)方法！");
        jdbcTemplate.update("insert into person(name) values(?)",
                new Object[]{person.getName()},
                new int[]{java.sql.Types.VARCHAR});
 
    }
 
    @Override
    public void update(Person person) {
        System.out.println("俺是update(Person person)方法！");
        jdbcTemplate.update("update person set name=? where id=?",
                new Object[]{person.getName(), person.getId()},
                new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});
 
    }
 
    @Override
    public Person getPerson(Integer personid) {
        System.out.println("俺是getPerson(Integer personid)方法！");
        return (Person) jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid},
                new int[]{java.sql.Types.INTEGER},
                new PersonRowMapper());
    }
 
    @Override
    public List<Person> getPersons() {
        System.out.println("俺是getPersons()方法！");
        return (List<Person>) jdbcTemplate.query("select * from person", new PersonRowMapper());
    }
 
    @Override
    public void delete(Integer personid) {
        System.out.println("俺是delete(Integer personid)方法！");
        jdbcTemplate.update("delete from person where id=?",
                new Object[]{personid},
                new int[]{java.sql.Types.INTEGER});
    }
 
    /**
     * @param dataSource the dataSource to set
     */
    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }
}
PersonServiceBeanTest.java
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
/**
 *
 * @author kang.cunhua
 */
public class PersonServiceBeanTest {
 
    private static PersonService personService;
 
    public PersonServiceBeanTest() {
    }
 
    @BeforeClass
    public static void setUpClass() throws Exception {
        ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
        personService = (PersonService) cxt.getBean("personService");
    }
 
    @AfterClass
    public static void tearDownClass() throws Exception {
    }
 
    @Before
    public void setUp() {
    }
 
    /**
     * Test of save method, of class PersonServiceBean.
     */
    @Test
    public void testSave() {
        for (int i = 0; i < 5; i++) {
            personService.save(new Person("传智播客" + i));
        }
 
    }
 
    /**
     * Test of getPerson method, of class PersonServiceBean.
     */
    @Test
    public void testGetPerson() {
        Person person = personService.getPerson(2);
        System.out.println(" testGetPerson() ：" + person.getName());
    }
 
    /**
     * Test of update method, of class PersonServiceBean.
     */
    @Test
    public void testUpdate() {
        Person person = personService.getPerson(2);
        person.setName("张**");
        personService.update(person);
 
    }
 
    /**
     * Test of getPersons method, of class PersonServiceBean.
     */
    @Test
    public void testGetPersons() {
        for (Person person:personService.getPersons()) {
            System.out.println("testGetPersons():" + person.getName());
        }
    }
 
    /**
     * Test of delete method, of class PersonServiceBean.
     */
    @Test
    public void testDelete() {
        personService.delete(1);
    }
}
输出：
2010-7-26 14:17:32 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1decdec: display name [org.springframework.context.support.ClassPathXmlApplicationContext@1decdec]; startup date [Mon Jul 26 14:17:32 CST 2010]; root of context hierarchy
2010-7-26 14:17:32 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
2010-7-26 14:17:33 org.springframework.context.support.AbstractApplicationContext obtainFreshBeanFactory
信息: Bean factory for application context [org.springframework.context.support.ClassPathXmlApplicationContext@1decdec]: org.springframework.beans.factory.support.DefaultListableBeanFactory@193722c
2010-7-26 14:17:33 org.springframework.core.io.support.PropertiesLoaderSupport loadProperties
信息: Loading properties file from class path resource [jdbc.properties]
2010-7-26 14:17:33 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@193722c: defining beans [org.springframework.beans.factory.config.PropertyPlaceholderConfigurer#0,dataSource,txManager,org.springframework.aop.config.internalAutoProxyCreator,org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#0,org.springframework.transaction.interceptor.TransactionInterceptor#0,org.springframework.transaction.config.internalTransactionAdvisor,personService]; root of factory hierarchy
俺是save(Person person)方法！
俺是save(Person person)方法！
俺是save(Person person)方法！
俺是save(Person person)方法！
俺是save(Person person)方法！
俺是getPerson(Integer personid)方法！
 testGetPerson() ：传智播客1
俺是getPerson(Integer personid)方法！
俺是update(Person person)方法！
俺是getPersons()方法！
testGetPersons():传智播客0
testGetPersons():张**
testGetPersons():传智播客2
testGetPersons():传智播客3
testGetPersons():传智播客4
俺是delete(Integer personid)方法！
视频给出的代码并没有DAO层，直接在service层进行了一些DAO层的操作。个人觉得还是独立出来dao层比较好。维护和扩展方便。可以参考俺上一讲的笔记后边作出的改进。

]]> http://www.guloulou.com/?feed=rss2&p=1974 0 脑残翻译成英文是虾米--再次见证汉语的博大精深和英语的幽默 http://www.guloulou.com/?p=1971 http://www.guloulou.com/?p=1971#comments Mon, 26 Jul 2010 05:04:25 +0000 guloulou http://www.guloulou.com/?p=1971 Your brain has two parts: 
one is left, and another is right. 
Your left brain has nothing right,
Your right brain has nothing left.
-------------------
据说是对中文网络名词[脑残]的翻译。
很传神。
许久没见到这么牛的翻译了。

]]> http://www.guloulou.com/?feed=rss2&p=1971 0 21_传智播客Spring2.5视频教程_搭建和配置Spring与jdbc整合的环境 http://www.guloulou.com/?p=1966 http://www.guloulou.com/?p=1966#comments Sun, 25 Jul 2010 05:06:04 +0000 guloulou http://www.guloulou.com/?p=1966 Update：2010.07.25,结合之前学习李勇老师的JDBC教程和自己的想法，初步实现了插入数据库操作！
 
21_传智播客Spring2.5视频教程_搭建和配置Spring与jdbc整合的环境
Spring+JDBC组合开发
使用Spring+JDBC集成步骤如下：
配置数据源，如
<bean id="dataSource" class="org.apache.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="org.gjt.mm.mysql.Driver" />
    <property name="url" value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&amp;characterEncoding=UTF-8" />
    <property name="username" value="root" />
    <property name="password" value="123456" />
    <!-- ........略 -->
</bean>
配置事务
配置事务时，需要在xml配置文件中引入用于声明食物的tx命名空间（见下页），事务的配置方式有两种：注解方式和基于XML配置方式。
本讲先讲解配置数据源：
添加jar包支持：commons-dbcp.jar、commons-logging.jar、commons-pool.jar;aspectjrt.jar、aspectjweaver.jar、cglib-nodep-2.1_3.jar、common-annotations.jar;spring.jar;mysql-connector-java-3.1.13-bin.jar
在spring配置文件中引入用于声明事务的tx命名空间
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-2.5.xsd 
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-2.5.xsd">
</beans>
采用注解方式配置事务
采用注解方式
<bean id = "txManager" class = "org.springframework.jdbc,datasource.DataSourceTransactionManager">
    <propertyname="dataSource" ref="dataSource" />
</bean>
<!-- 采用@Transactional注解方式使用事务 -->
<tx:annotation-driven transaction-manager="txManager" />
 
@Service @Transactional
public class PersonServiceBean implements PersonService {
}
且看源码：
创建表：person.sql
/*
Navicat MySQL Data Transfer
 
Source Server : localhost
Source Server Version : 50133
Source Host : localhost:3306
Source Database : itcast
 
Target Server Type : MYSQL
Target Server Version : 50133
File Encoding : 65001
 
Date: 2010-07-23 15:54:58
*/
 
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for `person`
-- ----------------------------
DROP TABLE IF EXISTS `person`;
CREATE TABLE `person` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-- ----------------------------
-- Records of person
-- ----------------------------
beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="org.gjt.mm.mysql.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&amp;characterEncoding=UTF-8" />
        <property name="username" value="root" />
        <property name="password" value=""/>
        <!-- 连接池启动时的初始值 -->
        <property name="initialSize" value="1" />
        <!-- 连接池的最大值 -->
        <property name="maxActive" value="500"/>
        <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
        <property name="maxIdle" value="2"/>
        <!-- 最小空闲值，当空闲的连接数少于阀值时，连接池就会去申请一些连接，以免洪峰来时来不及申请 -->
        <property name="minIdle" value="1" />
 
    </bean>
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 采用@Transactional注解方式使用事务 -->
    <tx:annotation-driven transaction-manager="txManager" />
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean" >
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>
Person.java
package cn.itcast.bean;
 
/**
 *
 * @author kang.cunhua
 */
public class Person {
 
    private Integer id;
    private String name;
 
    public Person() {
    }
 
    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
 
    /**
     * @return the id
     */
    public Integer getId() {
        return id;
    }
 
    /**
     * @param id the id to set
     */
    public void setId(Integer id) {
        this.id = id;
    }
 
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
 
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
}
PersonService.java
package cn.itcast.service;
 
import cn.itcast.bean.Person;
import java.util.List;
 
/**
 *
 * @author kang.cunhua
 */
public interface PersonService {
 
    /**
     * 保存person
     * @param person
     */
    public void save(Person person);
 
    /**
     * 更新person
     * @param person
     */
    public void update(Person person);
 
    /**
     * 获取person
     * @param personid
     * @return
     */
    public String getPerson(Integer personid);
    /**
     * 获取所有person
     * @return
     */
    public List<Person> getPersons();
    /**
     * 删除指定id的person
     * @param personid
     */
    public void delete (Integer personid);
}
PersonServiceBean.java
package cn.itcast.service.impl;
 
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import java.util.List;
import javax.sql.DataSource;
 
 
/**
 *
 * @author kang.cunhua
 */
public class PersonServiceBean implements PersonService {
    private DataSource dataSource;
 
    @Override
    public void save(Person person) {
        System.out.println("俺是save(Person person)方法！");
 
    }
 
    @Override
    public void update(Person person) {
        System.out.println("俺是update(Person person)方法！");
 
    }
 
    @Override
    public String getPerson(Integer personid) {
        System.out.println("俺是getPerson(Integer personid)方法！");
         return null;
    }
 
    @Override
    public List<Person> getPersons() {
        System.out.println("俺是getPersons()方法！");
         return null;
    }
 
    @Override
    public void delete(Integer personid) {
        System.out.println("俺是delete(Integer personid)方法！");
    }
 
    /**
     * @param dataSource the dataSource to set
     */
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
 
}
PersonServiceBeanTest.java
package cn.itcast.service.impl;
 
import cn.itcast.service.PersonService;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
/**
 *
 * @author kang.cunhua
 */
public class PersonServiceBeanTest {
    private static PersonService personService;
 
    public PersonServiceBeanTest() {
    }
 
    @BeforeClass
    public static void setUpClass() throws Exception {
        ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
        personService = (PersonService) cxt.getBean("personService");
    }
 
    @AfterClass
    public static void tearDownClass() throws Exception {
    }
 
    @Before
    public void setUp() {
    }
 
    /**
     * Test of save method, of class PersonServiceBean.
     */
    @Test
    public void testSave() {
 
 
        personService.save(null);
 
    }
 
    /**
     * Test of update method, of class PersonServiceBean.
     */
    @Test
    public void testUpdate() {
        personService.update(null);
    }
 
    /**
     * Test of getPerson method, of class PersonServiceBean.
     */
    @Test
    public void testGetPerson() {
        personService.getPerson(1);
    }
 
    /**
     * Test of getPersons method, of class PersonServiceBean.
     */
    @Test
    public void testGetPersons() {
        personService.getPersons();
    }
 
    /**
     * Test of delete method, of class PersonServiceBean.
     */
    @Test
    public void testDelete() {
        personService.delete(1);
    }
 
    /**
     * Test of setDataSource method, of class PersonServiceBean.
     */
    @Test
    public void testSetDataSource() {
    }
}
输出：
2010-7-23 16:03:10 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@fa7e74: display name [org.springframework.context.support.ClassPathXmlApplicationContext@fa7e74]; startup date [Fri Jul 23 16:03:10 CST 2010]; root of context hierarchy
2010-7-23 16:03:10 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
2010-7-23 16:03:10 org.springframework.context.support.AbstractApplicationContext obtainFreshBeanFactory
信息: Bean factory for application context [org.springframework.context.support.ClassPathXmlApplicationContext@fa7e74]: org.springframework.beans.factory.support.DefaultListableBeanFactory@4cee32
2010-7-23 16:03:10 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@4cee32: defining beans [dataSource,txManager,org.springframework.aop.config.internalAutoProxyCreator,org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#0,org.springframework.transaction.interceptor.TransactionInterceptor#0,org.springframework.transaction.config.internalTransactionAdvisor,personService]; root of factory hierarchy
俺是save(Person person)方法！
俺是update(Person person)方法！
俺是getPerson(Integer personid)方法！
俺是getPersons()方法！
俺是delete(Integer personid)方法！
-----------------------------青春靓丽阳光活力分割线--------------------------------
以上代码稍微比视频上的多一些；视频上讲解到搭建环境后，就结束了。也没有结合JDBC做一些单元测试；下一讲看了开头，貌似开始讲Spring的JDBC实现了。so，我补充了单元测试，以及需要的方法。初步模拟了一下方法调用。但并没有实际连数据库；
-----------------------------青春靓丽阳光活力分割线--------------------------------
以下的代码是今天2010.07.25补充的。觉得自己应该把整体的代码做个简单连接数据库测试。于是，翻了翻之前李勇老师的JDBC笔记，结合自己的想法，做了些许分层。整合在这一讲中了。
引入DAO、JdbcUtils，重新设计Service层；废话不说了，且看代码：
创建表：person.sql
/*
Navicat MySQL Data Transfer
 
Source Server : localhost
Source Server Version : 50133
Source Host : localhost:3306
Source Database : itcast
 
Target Server Type : MYSQL
Target Server Version : 50133
File Encoding : 65001
 
Date: 2010-07-23 15:54:58
*/
 
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for `person`
-- ----------------------------
DROP TABLE IF EXISTS `person`;
CREATE TABLE `person` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
-- ----------------------------
-- Records of person
-- ----------------------------
 beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
    <bean id="dataSource" destroy-method="close">
        <property name="driverClassName" value="org.gjt.mm.mysql.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&amp;characterEncoding=UTF-8" />
        <property name="username" value="root" />
        <property name="password" value=""/>
        <!-- 连接池启动时的初始值  -->
        <property name="initialSize" value="1" />
        <!-- 连接池的最大值 -->
        <property name="maxActive" value="500"/>
        <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
        <property name="maxIdle" value="2"/>
        <!-- 最小空闲值，当空闲的连接数少于阀值时，连接池就会去申请一些连接，以免洪峰来时来不及申请 -->
        <property name="minIdle" value="1" />

    </bean>
    <bean id="txManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 采用@Transactional注解方式使用事务 -->
    <tx:annotation-driven transaction-manager="txManager" />
    <bean id="jdbcUtils" >
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <bean id="personDao" >
        <property name="jdbcUtils" ref="jdbcUtils"></property>
    </bean>
    <bean id="personService" >
        <property name="personDao" ref="personDao"></property>
    </bean>

</beans>

Person.java

package cn.itcast.bean;

/**
 *
 * @author kang.cunhua
 */
public class Person {

    private Integer id;
    private String name;

    public Person() {
    }

    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    /**
     * @return the id
     */
    public Integer getId() {
        return id;
    }

    /**
     * @param id the id to set
     */
    public void setId(Integer id) {
        this.id = id;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
}

PersonDao.java

package cn.itcast.dao;

import cn.itcast.bean.Person;
import java.util.List;

/**
 *
 * @author kang.cunhua
 */
public interface PersonDao {
    /**
     * 保存person
     * @param person
     */
    public void save(Person person);

    /**
     * 更新person
     * @param person
     */
    public void update(Person person);

    /**
     * 获取person
     * @param personid
     * @return
     */
    public String getPerson(Integer personid);
    /**
     * 获取所有person
     * @return
     */
    public List<Person> getPersons();
    /**
     * 删除指定id的person
     * @param personid
     */
    public void delete (Integer personid);

}

PersonDaoBean.java

package cn.itcast.dao.impl;

import cn.itcast.bean.Person;
import cn.itcast.dao.PersonDao;
import cn.itcast.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author kang.cunhua
 */
public class PersonDaoBean implements PersonDao {

    private JdbcUtils jdbcUtils;

    @Override
    public void save(Person person) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "insert into person(name) values (?) ";
        try {
            conn = jdbcUtils.getConnection();
            ps = conn.prepareStatement(sql);
            ps.setString(1, person.getName());
            ps.execute();

        } catch (SQLException ex) {
            Logger.getLogger(PersonDaoBean.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
   JdbcUtils.free(rs, ps, conn);
  }
        System.out.println("俺是save(Person person)方法！");
    }

    @Override
    public void update(Person person) {
        System.out.println("俺是update(Person person)方法！");
    }

    @Override
    public String getPerson(Integer personid) {
        System.out.println("俺是getPerson(Integer personid)方法！");
        return null;
    }

    @Override
    public List<Person> getPersons() {
        System.out.println("俺是getPersons()方法！");
        return null;
    }

    @Override
    public void delete(Integer personid) {
        System.out.println("俺是getPersons()方法！");
    }

    /**
     * @param jdbcUtils the jdbcUtils to set
     */
    public void setJdbcUtils(JdbcUtils jdbcUtils) {
        this.jdbcUtils = jdbcUtils;
    }
}

PersonService.java

package cn.itcast.service;

import cn.itcast.bean.Person;
import java.util.List;

/**
 *
 * @author kang.cunhua
 */
public interface PersonService {
    public void regist(Person person);
    public List retrieve();
}

PersonServiceBean.java

package cn.itcast.service.impl;

import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import cn.itcast.dao.PersonDao;
import java.util.List;

/**
 *
 * @author kang.cunhua
 */
public class PersonServiceBean implements PersonService {

    private PersonDao personDao;

    @Override
    public void regist(Person person) {
        personDao.save(person);
    }

    @Override
    public List retrieve() {
        return personDao.getPersons();

    }

    /**
     * @param personDao the personDao to set
     */
    public void setPersonDao(PersonDao personDao) {
        this.personDao = personDao;
    }
}

JdbcUtil.java

package cn.itcast.utils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;

/**
 *
 * @author kang.cunhua
 */
public class JdbcUtils {

    private DataSource dataSource;

    public Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }

    /**
     * @param dataSource the dataSource to set
     */
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public static void free(ResultSet rs, Statement st, Connection conn) {
        try {
            if (rs != null) {
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (st != null) {
                    st.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                if (conn != null) {
                    try {
                        conn.close();
                        // myDataSource.free(conn);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

单元测试：PersonServiceBeanTest.java

package cn.itcast.service.impl;

import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 *
 * @author kang.cunhua
 */
public class PersonServiceBeanTest {

    private static PersonService personService;

    public PersonServiceBeanTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
        ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
        personService = (PersonService) cxt.getBean("personService");
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() {
    }

    /**
     * Test of save method, of class PersonServiceBean.
     */
    @Test
    public void testSave() {
        Person person = new Person();
        person.setName("郭德纲");
        personService.regist(person);
    }

    /**
     * Test of update method, of class PersonServiceBean.
     */
    @Test
    public void testRetrievee() {
        personService.retrieve();
    }
}

 

]]> http://www.guloulou.com/?feed=rss2&p=1966 0 20_传智播客Spring2.5视频教程_aspectj的切入点语法定义细节 http://www.guloulou.com/?p=1964 http://www.guloulou.com/?p=1964#comments Wed, 21 Jul 2010 08:52:46 +0000 guloulou http://www.guloulou.com/?p=1964 拦截所有方法：
(* cn.itcast.service.impl.PersonServiceBean.*(..))
只拦截返回值为String的方法：
(java.lang.String cn.itcast.service.impl.PersonServiceBean.*(..))
要求输入参数第一必须是String类型。后续不管有没有参数
(* cn.itcast.service.impl.PersonServiceBean.*(java.lang.String,..))
要求拦截所有返回值不是void的方法；
(!void cn.itcast.service.impl.PersonServiceBean.*(..))

针对最后一种需求，且看源代码：
beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <aop:aspectj-autoproxy/>
    <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean"/>
    <bean id="aspetbean" class="cn.itcast.aop.MyInterceptor"/>

    <aop:config>
        <aop:aspect id="asp" ref="aspetbean">
            <aop:pointcut id="mycut" expression="execution(!void cn.itcast.service.impl.PersonServiceBean.*(..))"/>
            <aop:before pointcut-ref="mycut" method="doAccessCheck"/>
            <aop:after-returning pointcut-ref="mycut" method="doAfterReturning" />
            <aop:after-throwing pointcut-ref="mycut" method="doAfterThrowing"/>
            <aop:after pointcut-ref="mycut" method="doAfter"/>
            <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>
        </aop:aspect>
    </aop:config>
</beans>

MyInterceptorTest.java

package cn.itcast.aop;

import cn.itcast.service.PersonService;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 *
 * @author kang.cunhua
 */
public class MyInterceptorTest {

    public MyInterceptorTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    /**
     * Test of doAccessCheck method, of class MyInterceptor.
     */
    @Test
    public void testDoAccessCheck() {
        ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
        PersonService personService = (PersonService) cxt.getBean("personService");
        personService.save("xxx");
        System.out.println("-----------------");
        personService.getPersonName(2);
    }
}

输出如下：

2010-7-21 16:47:15 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@cdfc9c: display name [org.springframework.context.support.ClassPathXmlApplicationContext@cdfc9c]; startup date [Wed Jul 21 16:47:15 CST 2010]; root of context hierarchy
2010-7-21 16:47:16 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
2010-7-21 16:47:16 org.springframework.context.support.AbstractApplicationContext obtainFreshBeanFactory
信息: Bean factory for application context [org.springframework.context.support.ClassPathXmlApplicationContext@cdfc9c]: org.springframework.beans.factory.support.DefaultListableBeanFactory@ba9340
2010-7-21 16:47:16 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@ba9340: defining beans [org.springframework.aop.config.internalAutoProxyCreator,personService,aspetbean,org.springframework.aop.aspectj.AspectJPointcutAdvisor#0,org.springframework.aop.aspectj.AspectJPointcutAdvisor#1,org.springframework.aop.aspectj.AspectJPointcutAdvisor#2,org.springframework.aop.aspectj.AspectJPointcutAdvisor#3,org.springframework.aop.aspectj.AspectJPointcutAdvisor#4,mycut]; root of factory hierarchy
我是save()方法！
-----------------
前置通知触发:
进入方法
我是getPersonName()方法！
后置通知触发:
最终通知触发！！
退出方法

除了beans.xml有少许改动，其他代码和上一讲一致；

]]> http://www.guloulou.com/?feed=rss2&p=1964 0