亚洲AV无码乱码麻豆精品国产,亚洲第一成年男人的天堂,亚洲国产精品无码中文lv

温故知新:spring_10整合Struts

Sun, 09 Nov 2014 01:38:00 GMT

整合struts�Q�就需要将action的实例交由spring��d��理，由此可想�Q�我们需要在��目开始的时候就��action的注入对象加载到spring的工厂里。除了添加struts的依赖，�q�需要添加struts和spring整合用的插�g

1         <dependency>
2             <groupId>org.apache.strutsgroupId>
3             <artifactId>struts2-spring-pluginartifactId>
4             <version>2.3.7version>
5         dependency>
6
7         <dependency>
8             <groupId>org.apache.strutsgroupId>
9             <artifactId>struts2-coreartifactId>
10             <version>2.3.7version>
11         dependency>

除了在测试类中能取得工厂�Q�通过BeanId在工厂中获取实例的情况，其他时候一般是通过自动扫描�q�注入，因此�Q�在web.xml中，除了struts的过滤器�Q�还需要额外添加spring上下文的监听器，在项目部�|�的时候就��action��d��到工�?br />

1     <listener>
2         <listener-class>
3             org.springframework.web.context.ContextLoaderListener
4         listener-class>
5     listener>
6     <context-param>
7         <param-name>contextConfigLocationparam-name>
8         <param-value>classpath*:beans.xmlparam-value>
9     context-param>

因�ؓ需要action被spring�q�行��理�Q�还需要在struts.xml配置中设�|�以下内�?/div>

1 <constant name="struts.objectFactory"
2         value="org.apache.struts2.spring.StrutsSpringObjectFactory" />
3     <constant name="struts.devMode" value="true" />
4
5     <package name="user" extends="struts-default" namespace="/">
6         <action name="*" class="userAction" method="{1}">
7             <result name="success">/user{1}.jspresult>
8         action>
9     package>

通过spring�q�行��理之后�Q�action的class配置��无需再写详细的类目录�Q�直接写作注入类的BeanId

1 package org.duyt.action;
2
3 import java.util.List;
4
5 import javax.annotation.Resource;
6
7 import org.duyt.domain.User;
8 import org.duyt.service.IuserService;
9 import org.springframework.context.annotation.Scope;
10 import org.springframework.stereotype.Controller;
11
12 import com.opensymphony.xwork2.ActionSupport;
13 import com.opensymphony.xwork2.ModelDriven;
14
15 @Controller("userAction")
16 //对于action�Q�需要额外指定Scope为prototype�Q�默认是单例模式
17 @Scope("prototype")
18 public class UserAction extends ActionSupport implements ModelDriven{
19
20     private static final long serialVersionUID = 2698940294947436354L;
21
22     private User user;
23     private List userList;
24
25     @Resource
26     private IuserService userService;
27
28
29     public String list() {
30
31         userList = userService.listUser();
32
33         return SUCCESS;
34     }
35
36     public User getModel() {
37         if (user == null) {
38             user = new User();
39         }
40         return user;
41     }
42
43   //get/set�Ҏ��?br />44
45 }
46

上述配置之后�Q�就完成了对struts的整合，但是整合之后�Q�可能会遇到以下的问题：
1�Q�关于声明式事务的切入点表达式。虽然执行对数据库操作的环节是Dao�Q�但是声明却不能在Dao�q�行事务处理�Q�毕竟一个Dao�Ҏ��据库的操作不一定能代表一个完整的事务。所以，切入点应该设�|�在service接口上，一个具体的业务处理应该包含一个完整的事务。拿最�l�典的银行�{账的例子来说�Q�一个�̎��L��金额转出操作和另一个�̎��L��转入操作应该讑֮�在一个service的方法里�Q�当事务对这个方法生效，那么不论转入或者�{��Z�Q何一个操作出现异常，那么整个操作都会回滚。倘若事务讑֮�在Dao上，那么转入和�{出分别�ؓ两个�Ҏ��Q�其中一个出现异�怹�后（一般也��是转出出现异常�Q�，会出现打钱收不到�Q�钱都不知道��d��儿了的情况，�q�是我们最不想看到的。可能你会说�Q�把转入和�{��定在Dao的一个方法中不就可以了，对，�q�样的话是可以解决问题，但是�q�样会导致层和层之间的分工不明确�Q�相互渗透的情况�Q�Dao只是�Ҏ��据库的访问，他不应该涉及�q�分的业务逻辑�Q�就像控制层应该把更多的�_�֊�攑֜�跌��{或者参��C��递上�Q�而不应该和专门控制业务处理的service层抢�z�d��。还有就是在Dao一个方法里�q�行业务逻辑操作可能会涉及Dao之间的嵌套调用，会出现问题�?br />2�Q�在��面上��用查询时。可能会出现以下的异�?br />

1     org.hibernate.LazyInitializationException: could not initialize proxy - no Session
2     at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:132)
3     at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:174)
4     at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:190)
5     at org.duyt.domain.Address_$$_javassist_0.toString(Address_$$_javassist_0.java)
6 ...

�q�是�׃��hibernate的懒加蝲机制引�v的，�׃��声明式事务将事务讑֮�在service的接口，��D��service�Ҏ��执行完毕��׃��关闭session�Q�那么到了页面上需要取得懒加蝲才能取得的信息时�Q�会��D��出现没有session的状态，那么如何解决呢。可以通过一个过滤器�Q��用Threadlocal在请求之初就开启session�Q�这��P��整个��程都可以取得session�Q�请求结束之时再关闭session。新增一个过滤器�Q�将spring工厂中的sessionfactory取得�Q�通过该工厂新建session

1 package org.duyt.filter;
2
3 import java.io.IOException;
4
5 import javax.servlet.Filter;
6 import javax.servlet.FilterChain;
7 import javax.servlet.FilterConfig;
8 import javax.servlet.ServletException;
9 import javax.servlet.ServletRequest;
10 import javax.servlet.ServletResponse;
11
12 import org.hibernate.Session;
13 import org.hibernate.SessionFactory;
14 import org.springframework.web.context.WebApplicationContext;
15 import org.springframework.web.context.support.WebApplicationContextUtils;
16
17 public class OpenSessionInViewFilter implements Filter{
18
19     //spring工厂
20     private static WebApplicationContext wac;
21     //hibernateSessionFactory
22     private static SessionFactory sessionFactory;
23     //�U�程间共享的session
24     private static ThreadLocal sessionholder = new ThreadLocal();
25
26     private static void setSession(Session session){
27         sessionholder.set(session);
28     }
29
30     public static Session getSession(){
31         return sessionholder.get();
32     }
33
34     private static void removeSession(){
35         sessionholder.remove();
36     }
37
38     public void destroy() {
39
40     }
41
42     public void doFilter(ServletRequest req, ServletResponse resp,
43             FilterChain chain) throws IOException, ServletException {
44         try {
45             //执行操作之前先设定session
46             if (sessionFactory != null) {
47                 setSession(sessionFactory.openSession());
48             }
49             chain.doFilter(req, resp);
50         } finally{
51             //操作完毕之后在移除session
52             removeSession();
53         }
54     }
55
56     public void init(FilterConfig cfg) throws ServletException {
57         //��spring的工厂加载到属�?br />58         //�q�里不要使用new classpathXml.. ��L��建工厂，应该使用��目启动时创建的工厂
59         //如下获取
60         wac = WebApplicationContextUtils.getWebApplicationContext(cfg.getServletContext());
61         sessionFactory = (SessionFactory) wac.getBean("sessionFactory");
62     }
63
64 }
65

之后�Q�在Dao中进行数据库操作时就需要��用过滤器创徏的session

1 OpenSessionInViewFilter.getSession().XXX

spring本��n也提供了一个叫OpenSessionInViewFilter的过滤器�Q�能帮助我们解决懒加载时没有session的问题，看下web.xml

1
2
3     <filter>
4         <filter-name>OpenSessionInViewFilterfilter-name>
5
6
7
8
9         <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilterfilter-class>
10     filter>
11     <filter-mapping>
12         <filter-name>OpenSessionInViewFilterfilter-name>
13         <url-pattern>/*url-pattern>
14     filter-mapping>

都较�?/a> 2014-11-09 09:38 发表评论

温故知新:spring_09整合Hibernate

Sat, 08 Nov 2014 16:37:00 GMT

摘要: 整合Hibernate和JDBC有些�c�M��的地方，spring依旧是处理了hibernate的公共打开关闭session�{�操作，但是详尽内容�q�是需要参阅文档http://docs.spring.io/spring-framework/docs/�Q�这里先记蝲一个和Hibernate3整合的常用案例。spring整合hibernate3和hibernate4�Q�这两个版本有一些差异。首先，整合spring... 阅读全文

都较�?/a> 2014-11-09 00:37 发表评论

温故知新:spring_08整合JDBC

Fri, 07 Nov 2014 13:44:00 GMT

摘要: spring整合JDBC的详�l�内定w��要参阅github上的spring相关文档�Q�传送门�Q�http://docs.spring.io/spring-framework/docs/�Q�这里记录一个spring和JDBC整合的常用案例搭建测试环境前�Q�首先添加相关的maven依赖Code highlighting produced by Actipro CodeHighlighter (freeware)h... 阅读全文

都较�?/a> 2014-11-07 21:44 发表评论

温故知新:spring_07��Z��XML配置AOP

Wed, 05 Nov 2014 14:45:00 GMT

相比较于使用annotation去配�|�，使用XML去配�|�AOP反而简单些�Q�无需在切面类中�ؓ每个通知�Ҏ��定义切入点表辑ּ��Q�切面类��z�且不受代码入��R�Q�非常的灉|��?br />

切面�c�，去除掉和AOP有关的注解，变得非常��z?br />

1 package org.duyt.autoProxy;
2
3 import org.aspectj.lang.JoinPoint;
4 import org.aspectj.lang.ProceedingJoinPoint;
5 import org.duyt.util.Logger;
6 import org.springframework.stereotype.Component;
7
8 @Component("loggerAspect")
9 public class LoggerAspect {
10     public void loggerBefore(JoinPoint jp) {
11         Logger.info("前置切入点：execute==>" + jp.getTarget() + "==>"
12                 + jp.getSignature().getName() + " method");
13     }
14     public void loggerAfter(JoinPoint jp) {
15         Logger.info("后置切入点：execute==>" + jp.getTarget() + "==>"
16                 + jp.getSignature().getName() + " method");
17     }
18     public void loggerAround(ProceedingJoinPoint pjp) throws Throwable {
19         Logger.info("环绕开始切入点�Q�execute==>" + pjp.getTarget() + "==>"
20                 + pjp.getSignature().getName() + " method");
21         pjp.proceed();
22         Logger.info("环绕�l�束切入点：execute==>" + pjp.getTarget() + "==>"
23                 + pjp.getSignature().getName() + " method");
24     }
25 }
26

beans.xml变更��Z��下的配置

1 xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
4     xmlns:aop="http://www.springframework.org/schema/aop"
5     xsi:schemaLocation="http://www.springframework.org/schema/beans
6                         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
7                         http://www.springframework.org/schema/context
8                         http://www.springframework.org/schema/context/spring-context-3.0.xsd
9                         http://www.springframework.org/schema/aop
10                         http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
11
12
13     <context:annotation-config />
14
15     <context:component-scan base-package="org.duyt.*" />
16
17
18
19
20
21
22     <aop:config>
23
24         <aop:aspect id="loggerAspect" ref="loggerAspect">
25
26             <aop:pointcut id="loggerPointcut"
27                 expression="execution (* org.duyt.dao.*.add*(..))||
28                             execution (* org.duyt.dao.*.delete*(..))||
29                             execution (* org.duyt.dao.*.update*(..))" />
30
31             <aop:before method="loggerBefore" pointcut-ref="loggerPointcut"/>
32
33             <aop:after method="loggerAfter" pointcut-ref="loggerPointcut"/>
34
35             <aop:around method="loggerAround" pointcut-ref="loggerPointcut"/>
36         aop:aspect>
37     aop:config>
38
39 beans>

��试�c?br />

1 package org.duyt.test;
2
3 import org.duyt.action.UserAction;
4 import org.junit.Test;
5 import org.springframework.beans.factory.BeanFactory;
6 import org.springframework.context.support.ClassPathXmlApplicationContext;
7
8 public class IocTest {
9
10     private BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");
11
12     @Test
13     public void test(){
14         //��Z��XML的AOP
15         UserAction ua = (UserAction) factory.getBean("userAction");
16         ua.addUser();
17     }
18
19 }
20

�l�果和��用annotation无异�Q?br />

前置切入点：execute==>org.duyt.dao.impl.UserDao@af08a49==>add method

环绕开始切入点�Q�execute==>org.duyt.dao.impl.UserDao@af08a49==>add method

用户增加�Ҏ��

后置切入点：execute==>org.duyt.dao.impl.UserDao@af08a49==>add method

环绕�l�束切入点：execute==>org.duyt.dao.impl.UserDao@af08a49==>add method

都较�?/a> 2014-11-05 22:45 发表评论

温故知新:spring_06��Z��annotation配置AOP

Wed, 05 Nov 2014 03:09:00 GMT

要��用注解去配置AOP�Q�首先要在spring的配�|�中开启切面自动代理�?br />

此时�Q�需要加入aop对应的命名空��_��虽然搜烦一下会有一大堆�Q�但是这�U�命名空间的声明会在spring-XXX相应的包下找刎ͼ�要加入aop的声明，可在spring-aop-X.X.X.jar包，META-INF下的spring.schemas�Q�spring.tooling配置文�g中找到�?br />在定义切面之前，�q�是先理清一些概�?br />1�Q�切入点�Q�point-cut�Q�，核心是切入点表达式，可以��定��h��程中的某一个点�?br />2�Q�通知�Q�advice�Q�，可以理解为在切入点的某个位置�Q�常见如切入点之前，之后�Q�或者环�l�着切入点）��d��需要拓展的功能�Q�通知包含切入的具体位�|�和拓展的内宏V�?br />3�Q�切面（aspect�Q�，一�c�d��入点�Q�比如专门添加日志的切面�Q�或者专门记录异常的切面�Q�可以理解�ؓ�l�成了一个切面，切面包含了切入点和所需要的通知�?br />下面定义一个切面：

1 package org.duyt.autoProxy;
2
3 import org.aspectj.lang.JoinPoint;
4 import org.aspectj.lang.ProceedingJoinPoint;
5 import org.aspectj.lang.annotation.After;
6 import org.aspectj.lang.annotation.Around;
7 import org.aspectj.lang.annotation.Aspect;
8 import org.aspectj.lang.annotation.Before;
9 import org.duyt.util.Logger;
10 import org.springframework.stereotype.Component;
11
12 /**
13  * Spring使用了第三方AspectJ来实现AOP功能�Q�AOP相关的注解需要添加AspectJ的饮�?br />14  * @author Administrator
15  *
16  */
17 //注明�q�是一个切面类
18 @Aspect
19 //��d��spring的管�?/span>
20 @Component("loggerAspect")
21 public class LoggerAspect {
22     //@Before标注的方法意为将该方法作用于切入点表辑ּ�注明的方法之前执行，可以理解为创��Z��个通知�Q?br />23     //关于切入点表辑ּ��Q�execution(* org.duyt.dao.*.add*(..)
24     //�W�一�?代表着��L��c�d��q�回值的�Ҏ��
25     //之后跟空��|��d��一个包的�\径，�W�二�?表示该包路径下的所有类
26     //之后��d��“.”�Q�再跟需要切入的�Ҏ��Q�此处指定了所有以add,delete,update开头的�Ҏ��Q��?#8220;||”�q�列�q�接�q�些表达�?br />27     //最后的“(..)”表示��L��个数的参数列�?/span>
28     @Before("execution(* org.duyt.dao.*.add*(..))||"
29             + "execution(* org.duyt.dao.*.delete*(..))||"
30             + "execution(* org.duyt.dao.*.update*(..))")
31     public void loggerBefore(JoinPoint jp) {
32         // System.out.println(jp.getTarget());//org.duyt.dao.impl.UserDao@71eecfa7�Q�获取执行的对象
33         // System.out.println(jp.getSignature().getName());//add�Q�获取方法签�?/span>
34         Logger.info("前置切入点：execute==>" + jp.getTarget() + "==>"
35                 + jp.getSignature().getName() + " method");
36     }
37     @After("execution(* org.duyt.dao.*.add*(..))||"
38             + "execution(* org.duyt.dao.*.delete*(..))||"
39             + "execution(* org.duyt.dao.*.update*(..))")
40     public void loggerAfter(JoinPoint jp) {
41         Logger.info("后置切入点：execute==>" + jp.getTarget() + "==>"
42                 + jp.getSignature().getName() + " method");
43     }
44     @Around("execution(* org.duyt.dao.*.add*(..))||"
45             + "execution(* org.duyt.dao.*.delete*(..))||"
46             + "execution(* org.duyt.dao.*.update*(..))")
47     public void loggerAround(ProceedingJoinPoint pjp) throws Throwable {
48         Logger.info("环绕开始切入点�Q�execute==>" + pjp.getTarget() + "==>"
49                 + pjp.getSignature().getName() + " method");
50         pjp.proceed();//执行�Ҏ��
51         Logger.info("环绕�l�束切入点：execute==>" + pjp.getTarget() + "==>"
52                 + pjp.getSignature().getName() + " method");
53     }
54 }
55

DAO和Service内容略，��试�c�d��?br />

1 package org.duyt.test;
2
3 import org.duyt.action.UserAction;
4 import org.junit.Test;
5 import org.springframework.beans.factory.BeanFactory;
6 import org.springframework.context.support.ClassPathXmlApplicationContext;
7
8 public class IocTest {
9
10     private BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");
11
12     @Test
13     public void test(){
14         //��Z��annotation的AOP
15         UserAction ua = (UserAction) factory.getBean("userAction");
16         ua.addUser();
17     }
18
19 }
20

�l�果�Q?br />

前置切入点：execute==>org.duyt.dao.impl.UserDao@6fc8ddb5==>add method

环绕开始切入点�Q�execute==>org.duyt.dao.impl.UserDao@6fc8ddb5==>add method

用户增加�Ҏ��

后置切入点：execute==>org.duyt.dao.impl.UserDao@6fc8ddb5==>add method

环绕�l�束切入点：execute==>org.duyt.dao.impl.UserDao@6fc8ddb5==>add method

都较�?/a> 2014-11-05 11:09 发表评论

温故知新:spring_05动态代理实现AOP

Tue, 04 Nov 2014 15:24:00 GMT

使用动态代理实现AOP�Q�就无需像静态代理那样一对一的去创徏代理�c�，而是创徏一个通用的代理类��L��收�ƈ创徏需要代理的对象�Q��ƈ在代理对象中拓展被代理对象的功能。就比如�Q�我们需要拓展DAO所有实现类的功能，在每个实现类的每个方法中都添加记录日志的功能�?br />

IUserDao

1 package org.duyt.dao;
2 import org.duyt.annotation.LogMsg;
3 public interface IUserDao {
4 public void add();
5 }

UserDao

1 package org.duyt.dao.impl;
2 import org.duyt.dao.IUserDao;
3 import org.springframework.context.annotation.Scope;
4 import org.springframework.stereotype.Repository;
5 @Repository("userDao")
6 @Scope("singleton")
7 public class UserDao implements IUserDao {
8     public void add() {
9         System.out.println("用户增加�Ҏ��");
10     }
11 }

创徏代理�c�，�q�个代理�cȝ��主要作用��是��Z��入的被代理对象，��d��Ҏ��执行前的记录日志功能

1 package org.duyt.dao.proxy;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5 import java.lang.reflect.Proxy;
6
7 public class DaoLoggerProxy implements InvocationHandler {
8
9     //使用属性保存，要代理的目标对象
10     private Object target;
11
12     //�U�有�I�构�?/span>
13     private DaoLoggerProxy(){
14     }
15
16     //工厂�Ҏ��
17     public static Object getInstance(Object o){
18         DaoLoggerProxy proxy = new DaoLoggerProxy();
19         //保存要代理的对象
20         proxy.target = o;
21         //创徏传入对象的代理对�?/span>
22         Object result = Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(), proxy);
23         //�q�回创徏的代理对�?/span>
24         return result;
25     }
26
27     //被代理对象在调用��M��Ҏ��的时候，都会先调用代理类的invoke�Ҏ��Q�那么在此，��可以在被代理对象方法执行的��L��一个流�E�添加需要的功能
28     public Object invoke(Object proxy, Method method, Object[] args)
29             throws Throwable {
30
31         /*if (method.isAnnotationPresent(XXX.class)) {
32             可以自定义注解给特定�Ҏ��Q�规定这些方法执行哪些特�D�的操作
33         }*/
34
35         /*if (method.getName().startsWith("add")) {
36             �Ҏ��些约定了�Ҏ��名的�Ҏ��拓展需要的功能
37         }*/
38
39         /*try {
40             Object obj = method.invoke(target, args);
41         } catch (Exception e) {
42             记录异常的操作，或者回滚操�?br />43         }*/
44
45         //在被代理对象�Ҏ��执行之前�q�行某些操作
46
47         System.out.println("---->模拟记录日志<----");
48         Object obj = method.invoke(target, args);
49
50         //之后�q�行某些操作
51
52         return obj;
53     }
54
55 }
56

beans.xml需要作出如下配�|?br />

1 xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4     xmlns:context="http://www.springframework.org/schema/context"
5     xsi:schemaLocation="http://www.springframework.org/schema/beans
6                         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
7                         http://www.springframework.org/schema/context
8                         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
9
10
11     <context:annotation-config/>
12
13     <context:component-scan base-package="org.duyt.*"/>
14
15
16     <bean id="daoLoggerProxy" class="org.duyt.dao.proxy.DaoLoggerProxy" factory-method="getInstance">
17
18         <constructor-arg ref="userDao"/>
19     bean>
20
21 beans>

配置完毕之后�Q��用代理注入userDao�Q�@Resource(name = "daoLoggerProxy")�Q�测�?br />

1 package org.duyt.test;
2
3 import org.duyt.action.UserAction;
4 import org.junit.Test;
5 import org.springframework.beans.factory.BeanFactory;
6 import org.springframework.context.support.ClassPathXmlApplicationContext;
7
8 public class IocTest {
9
10     private BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");
11
12     @Test
13     public void test(){
14         //��试代理�c�L��展的功能
15         UserAction ua = (UserAction) factory.getBean("userAction");
16         ua.addUser();
17     }
18
19 }
20

�l�果�Q?br />

---->模拟记录日志<----

用户增加�Ҏ��

都较�?/a> 2014-11-04 23:24 发表评论

温故知新:spring_04静态代理实现AOP

Tue, 04 Nov 2014 06:57:00 GMT

spring的另一个重要特性是AOP�Q?span style="color: #333333; font-family: arial, 宋体, sans-serif; line-height: 24px; text-indent: 28px; background-color: #ffffff;">Aspect Oriented Programming�Q�面向切面的�~�程�Q�spring的AOP�Ҏ��得对于��用了该特性的��目的可�l�护性，易拓展性和开发难易度�{�等都有了不同程度的改善。AOP�Ҏ��能够��得项目中的某些操作，在执行到某一个指定环节的时候，可以额外的去执行开发者指定的操作�Q�这些操作往往都是��h��共通性，而且可能和操作本�w�所包含的业务逻辑没有直接的关�p�，比如�Ҏ��据库的访问，涉及变更数据库内容的操作需要精准的记录日志�Q�每当��生异常或者错误信息的时候，也需要记录错误信息；�Ҏ��务器敏感资源�q�行讉K��的时候需要对用户的权限进行校验等。在哪些环节��d��处理�Q�做怎样的处理，都可以由开发者自定义�Q�十分灵�z�，而且在开发业务逻辑和流�E�的时候大可不必去考虑�q�些共同性质的处理，让主要精力都投入在业务的实现上，�q�样一来，开发效率会大大提高�?br />

先从一个静态代理的例子来感受一下这�U�切入式的编�E?br />IUserDao

1 package org.duyt.dao;
2 public interface IUserDao {
3 public void add();
4 }

UserDao

1 package org.duyt.dao.impl;
2
3 import org.duyt.dao.IUserDao;
4 import org.springframework.context.annotation.Scope;
5 import org.springframework.stereotype.Repository;
6
7 @Repository("userDao")
8 @Scope("singleton")
9 public class UserDao implements IUserDao {
10     public void add() {
11         System.out.println("用户增加�Ҏ��");
12     }
13 }
14

一个很单纯的接口实现。倘若�q�就是一个成品了�Q�测试通过没有问题�Q�可以上�U��用。一�D�|��间之后，需要加入日志的功能�Q�那么问题来了，挖掘机哪...噢不对，该如何添加呢�Q?br />或许会马上想刎ͼ�直接该啊。那么问题又来了�Q�挖...噢不�Q�直接修改的话，代码��需要测试，而且万一需要修改的地方很多呢，岂不是很痛苦�Q�况且直接修�Ҏ��代码�q�违背了OCP原则�Q�绝对不推荐。这时候就可以考虑使用代理�c�L��l�源代码增加新功能�?br />代理�Q�望文生义，白话��是“你要做的事儿我不仅能�l�你做了�Q�而且除此之外我还能多做别�?#8221;�Q�定义一个UserProxyDao

1 package org.duyt.dao.impl;
2
3 import javax.annotation.Resource;
4
5 import org.duyt.dao.IUserDao;
6 import org.duyt.util.Logger;
7 import org.springframework.context.annotation.Scope;
8 import org.springframework.stereotype.Repository;
9
10 @Repository("userProxyDao")
11 @Scope("singleton")
12 public class UserProxyDao implements IUserDao {
13
14     @Resource
15     private IUserDao userDao;
16
17     public void add() {
18         Logger.info("使用代理�Q��ؓ用户增加�Ҏ��d��日志");
19         userDao.add();
20
21     }
22
23 }
24

在代理中�Q�将需要拓展功能的对象作�ؓ代理的属性注入，然后在需要拓展的�Ҏ��前后�q�加需要的功能。在此之后，在给service的IuserDao对象注入实例的时候，要��用代理的对象@Resource(name = "userProxyDao")�Q�测试一�?br />

1 package org.duyt.test;
2
3 import org.duyt.action.UserAction;
4 import org.junit.Test;
5 import org.springframework.beans.factory.BeanFactory;
6 import org.springframework.context.support.ClassPathXmlApplicationContext;
7
8 public class IocTest {
9
10     private BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");
11
12     @Test
13     public void test(){
14         //��试代理依赖注入
15         UserAction ua = (UserAction) factory.getBean("userAction");
16         ua.addUser();
17     }
18
19 }
20

�l�果�Q?br />

使用代理�Q��ؓ用户增加�Ҏ��d��日志

用户增加�Ҏ��

�׃��IOC和AOP的特性，你会发现你要做的更改十分的少�Q�仅仅只是新增了一个代理类�Q��ƈ修改了注入的对象。虽焉��态的代理可以实现我们的需求，但是毕竟不灵�z�，一旦修�Ҏ��及的�Ҏ��和类一多，那简直就是纯体力�z�M��Q�一个类的拓展就需要对应一个代理类�Q�一个代理类中还需要涵盖所有需要拓展的�Ҏ��Q��ƈ且保证原有功能不受媄响，如此一来，功能拓展�q�一丑֊��需要投入极大的成本�Q�入不敷出�?img src ="http://m.tkk7.com/produ/aggbug/419488.html" width = "1" height = "1" />

都较�?/a> 2014-11-04 14:57 发表评论

温故知新:spring_03��Z��annotation配置IOC

Tue, 04 Nov 2014 03:17:00 GMT

相比较��用XML配置�Q�基于annotation的IOC配置会极大的��化配�|�文件的内容�Q�所以在beans.xml中无需再配�|�bean的设�|�，只需要开启组件扫描即可�?br />

1 xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4     xmlns:context="http://www.springframework.org/schema/context"
5     xsi:schemaLocation="http://www.springframework.org/schema/beans
6                         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
7                         http://www.springframework.org/schema/context
8                         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
9
10
11     <context:annotation-config/>
12
13     <context:component-scan base-package="org.duyt.*"/>
14
15 beans>

拿出一个Dao�l��g的注入�ؓ�?br />

1 package org.duyt.dao;
2 public interface IUserDao {
3     public void add();
4     public void delete();
5     public void update();
6     public void load();
7 }

Dao的实�?br />

1 package org.duyt.dao.impl;
2
3 import org.duyt.dao.IUserDao;
4 import org.springframework.context.annotation.Scope;
5 import org.springframework.stereotype.Repository;
6
7 //使用Repository("userDao")标注UserDao�cȝ��当于在配�|�文件中写作
8 //
9 @Repository("userDao")
10 //相应的，Scope("singleton")标注��q��当于的配�|�scope="singleton"
11 @Scope("singleton")
12 public class UserDao implements IUserDao {
13     public void add() {
14         System.out.println("用户增加�Ҏ��");
15     }
16     public void delete() {
17         System.out.println("用户删除�Ҏ��");
18     }
19     public void update() {
20         System.out.println("用户更新�Ҏ��");
21     }
22     public void load() {
23         System.out.println("用户查询�Ҏ��");
24     }
25 }
26

spring提供了三�U�注解来对应MVC的三层，数据层的注解对应Repository�Q�业务层对应service�Q�表�C�层对应controller。还有一个公��q��component�Q�分开�q�么多是��Z��更好的标注当前这个待注入�cȝ��功能�Q�如果不按照�q�些分类好的注解��L��入也可以完成注入�Q�但是还是规范的��d��。关于对象中某个属性的注入看下面的action

1 package org.duyt.action;
2
3 import javax.annotation.Resource;
4
5 import org.duyt.domain.User;
6 import org.duyt.service.IUserService;
7 import org.springframework.context.annotation.Scope;
8 import org.springframework.stereotype.Controller;
9
10 @Controller("userAction")
11 @Scope("prototype")
12 public class UserAction {
13     @Resource
14     private IUserService userService;
15     public String testString;
16     public User user;
17
18     public UserAction() {
19     }
20
21     public UserAction(String testString) {
22         super();
23         this.testString = testString;
24     }
25
26     public void addUser(){
27         userService.add();
28     }
29     //get/set�?/span>
30 }
31

对于某个要注入的属性，Spring自带的注解是@AutoWire�Q�但是这�U�是按照�c�d��注入的，��Z��避免接口多实现可能出现的问题�Q�推荐可以��用javax.annotation提供的@resource�Q�这�U�是按照属性的名称�q�行注入�Q�可以直接在属性名之上��d��注解�Q�这��L��话连属性的get/set都可以省�?..或者是��d��对应的get/set�Q�在set�Ҏ��上添加注解。但是要注意的是�Q�按照属性名字进行注入，属性的名称需要和注解定义�l��g时的id一致。Action中的Iuserservice的实例名为userService�Q�会��L��有@service("userService")的注解进行注入，否则会注入失败�?br />��试如下

1 package org.duyt.test;
2 import org.duyt.action.UserAction;
3 import org.junit.Test;
4 import org.springframework.beans.factory.BeanFactory;
5 import org.springframework.context.support.ClassPathXmlApplicationContext;
6 public class IocTest {
7     private BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");
8     @Test
9     public void test(){
10
11         //��试依赖注入
12         UserAction ua = (UserAction) factory.getBean("userAction");
13         UserAction ua2 = (UserAction) factory.getBean("userAction");
14         System.out.println(ua == ua2);
15         ua.addUser();
16     }
17 }
18

�l�果为：

false

用户增加�Ҏ��

都较�?/a> 2014-11-04 11:17 发表评论

温故知新:spring_02��Z��XML配置IOC

Mon, 03 Nov 2014 14:46:00 GMT

�W�一个案例已�l�是��Z��XML配置spring的工厂了�Q�那么现在，正了八景的配�|�一下�?br />

MVC 的三层式�l�构已经深入人心了，但是在此不得不稍微吐槽一下，虽然层次清晰�Q�但是还是有不少开发者，甚至一些站点，��这些层�ơ�؜淆，在本来单单是界面层的��?面中�Q�或者是控制器中嵌入了大量的业务代码�Q�而业务层和数据层却干�q�净净�Q�就是定义了单纯接口加对应实现。更有甚者在DAO中取request...你要�q�么写还分毛�U�层�?..�U�层�?..层啊�Q�咳�?..�a�归正传，定义好演�C�用的数据层和业务层的接口和实现�c?/div>

DaoInterface

1 package org.duyt.dao;
2 public interface IUserDao {
3 public void add();
4 }

DaoImpl

1 package org.duyt.dao.impl;
2 import org.duyt.dao.IUserDao;
3 public class UserDao implements IUserDao {
4     public void add() {
5         System.out.println("用户增加�Ҏ��");
6     }
7 }

ServiceInterface

1 package org.duyt.service;
2 public interface IUserService {
3 public void add();
4 }
5

ServiceImpl

1 package org.duyt.service.impl;
2 import org.duyt.dao.IUserDao;
3 import org.duyt.service.IUserService;
4 public class UserService implements IUserService {
5     private IUserDao userDao;
6     public void add() {
7         userDao.add();
8     }
9     public IUserDao getUserDao() {
10         return userDao;
11     }
12     public void setUserDao(IUserDao userDao) {
13         this.userDao = userDao;
14     }
15 }

实体�c?br />

1 package org.duyt.domain;
2 import java.util.List;
3 import java.util.Map;
4 public class User {
5     private int id;
6     private String name;
7     private Map mapTest;
8     private List listTest;
9     public User() {
10     }
11     public User(int id, String name) {
12         this.id = id;
13         this.name = name;
14     }
15 //get/set�?/span>
15 }
16

Action

1 package org.duyt.action;
2 import org.duyt.domain.User;
3 import org.duyt.service.IUserService;
4 public class UserAction {
5     private IUserService userService;
6     private String testStringA;
7     private String testStringB;
8     private User user;
9     public UserAction(String testStringA,String testStringB) {
10         this.testStringA = testStringA;
11         this.testStringB = testStringB;
12     }
13     public UserAction() {
14     }
15     //get/set�?/span>
16 }
17

1 package org.duyt.action;
2 import org.duyt.service.IUserService;
3 public class AutowiredAction {
4     private IUserService userService;
5     public void add(){
6         userService.add();
7     }
8 //get/set�?/span>
9 }
10

重点是beans.xml的配�|?br />

1 xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4     xsi:schemaLocation="http://www.springframework.org/schema/beans
5                         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd" >
6
7
8
10
11
15     <bean id="userAction" class="org.duyt.action.UserAction" scope="prototype">
16
17         <property name="userService" ref="userService"/>
18         <property name="user" ref="user"/>
19
20
21         <constructor-arg name="testStringA" value="��试用字�W�串AAA"/>
22         <constructor-arg name="testStringB" value="��试用字�W�串BBB"/>
23     bean>
24
25
26     <bean id="user" class="org.duyt.domain.User" scope="prototype">
27         <property name="id" value="1"/>
28         <property name="name" value="duyt"/>
29
30         <property name="mapTest">
31             <map>
32                 <entry key="1" value="nihao"/>
33                 <entry key="2" value="hello"/>
34             map>
35         property>
36
37         <property name="listTest">
38             <list>
39                 <value>1value>
40                 <value>2value>
41                 <value>3value>
42             list>
43         property>
44     bean>
45
46
49     <bean id="autowiredAction" class="org.duyt.action.AutowiredAction" scope="prototype" autowire="byName"/>
50
51     <bean id="userDao" class="org.duyt.dao.impl.UserDao" scope="singleton"/>
52     <bean id="userService" class="org.duyt.service.impl.UserService" scope="singleton">
53         <property name="userDao" ref="userDao"/>
54     bean>
55
56 beans>

最后��用测试类来验证注入的情况

1 package org.duyt.test;
2
3 import org.duyt.action.AutowiredAction;
4 import org.duyt.action.UserAction;
5 import org.junit.Test;
6 import org.springframework.beans.factory.BeanFactory;
7 import org.springframework.context.support.ClassPathXmlApplicationContext;
8
9 public class IocTest {
10
11     private BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");
12
13     @Test
14     public void test(){
15         UserAction ua = (UserAction) factory.getBean("userAction");
16         //��试使用构造方法进行注�?/span>
17         System.out.println(ua.getTestStringA());
18         System.out.println(ua.getTestStringB());
19         //属性注�?/span>
20         System.out.println(ua.getUser().getId());
21         System.out.println(ua.getUser().getName());
22         //集合注入
23         System.out.println(ua.getUser().getListTest().size());
24         System.out.println(ua.getUser().getMapTest().get("1"));
25         //�Ҏ��属性名自动注入
26         AutowiredAction aa = (AutowiredAction) factory.getBean("autowiredAction");
27         aa.add();
28     }
29
30 }
31

都较�?/a> 2014-11-03 22:46 发表评论

温故知新:spring_01IOC整体感受

Mon, 03 Nov 2014 09:19:00 GMT

IOC�Q�inverse of control�Q�控制反转，是spring提供的非�怼��U�的一�U�特性，�q�种�Ҏ��得在��目中，所有对象的实例都交由spring��d��建，��理。�ؓ什么要�q�么做呢�Q�假使我们脱��spring�Q�在开发的�q�程中，需要新建实例的时候自己去new�Q�那么组件之间的耦合度会非常高，在一个业务处理类中，某个对象��写��d��用某个实例，一旦有较大的业务变��_��需要修改的地方可能会多的不敢想象，如果文档�Q�代码和注释的维护较差，那么业务变更��直就是噩梦。spring的IOC�Ҏ��就助力实现�?#8220;高内聚，低耦合”的这�U�设计理��c�?br />记录一下��^时在使用spring时的一些技巧和心得�Q�先说明一下测试环境�?br />

环境如下
�pȝ��Q?/strong>64位win7

��试环境�Q?/strong>

先从一个helloworld的简单案例开始吧
新徏一个maven��目�Q�选择

其实不论使用哪个框架技术，都无非三步走�Q�import�Q�config�Q�run�Q�首先，我们import
因�ؓ使用maven来管理项目，所以直接添加spring的依赖到pom.xml
1         <dependency>
2             <groupId>org.springframeworkgroupId>
3             <artifactId>spring-coreartifactId>
4             <version>3.0.5.RELEASEversion>
5         dependency>
6
7         <dependency>
8             <groupId>org.springframeworkgroupId>
9             <artifactId>spring-contextartifactId>
10             <version>3.0.5.RELEASEversion>
11         dependency>
之后�Q�我们开始config�Q�作��Z��个基本IOC演示�Q�只需要定义工厂的配置。定义一个beans.xml文�g�Q�置于src下。其中bean标签��是定义beanId和待注入对象实例之间的映��?br />��是“用这个id取对象实例，你会取到class的对象实�?#8221;
1 xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4     xsi:schemaLocation="http://www.springframework.org/schema/beans
5                         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
6
7     <bean id="helloSpring" class="demo.model.Demo"/>
8
9 beans>
演示�c?br />
1 package demo.model;
2
3 public class Demo {
4
5     public Demo() {
6     }
7
8     public void hello(){
9         System.out.println("hello");
10     }
11 }
12
��试�c?br />
1 package org.duyt.test;
2
3 import org.duyt.model.Demo;
4 import org.junit.Test;
5 import org.springframework.beans.factory.BeanFactory;
6 import org.springframework.context.support.ClassPathXmlApplicationContext;
7
8 public class SpringDemo {
9
10     //��d��指定的工厂配�|�文件到spring的容器，文�g名可自定�?/span>
11     private BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");
12
13     @Test
14     public void test(){
15         //�Ҏ��bean的key获取对象的实�?/span>
16         Demo d = (Demo) factory.getBean("helloSpring");
17         //或者直接��用重载的getBean�Ҏ��Q�设定好需要返回的�c�d��
18         //Demo dd =  factory.getBean("helloSpring", Demo.class);
19         d.hello();
20         //dd.hello();
21     }
22
23 }
24
以上�Q�就是spingIOC最��易的使用�?/div>

都较�?/a> 2014-11-03 17:19 发表评论