BlogJava-1024-文章分类-containerFramework

温故知新:spring_10整合Struts

都较瘦 — Sun, 09 Nov 2014 01:38:00 GMT

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

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>

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

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进行管理，还需要在struts.xml配置中设置以下内容

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进行管理之后，action的class配置就无需再写详细的类目录，直接写作注入类的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，需要额外指定Scope为prototype，默认是单例模式
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方法略
44
45 }
46

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

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 ...

这是由于hibernate的懒加载机制引起的，由于声明式事务将事务设定在service的接口，导致service方法执行完毕就会关闭session，那么到了页面上需要取得懒加载才能取得的信息时，会导致出现没有session的状态，那么如何解决呢。可以通过一个过滤器，使用Threadlocal在请求之初就开启session，这样，整个流程都可以取得session，请求结束之时再关闭session。新增一个过滤器，将spring工厂中的sessionfactory取得，通过该工厂新建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     //线程间共享的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的工厂加载到属性
58         //这里不要使用new classpathXml.. 去新建工厂，应该使用项目启动时创建的工厂
59         //如下获取
60         wac = WebApplicationContextUtils.getWebApplicationContext(cfg.getServletContext());
61         sessionFactory = (SessionFactory) wac.getBean("sessionFactory");
62     }
63
64 }
65

之后，在Dao中进行数据库操作时就需要使用过滤器创建的session

1 OpenSessionInViewFilter.getSession().XXX

spring本身也提供了一个叫OpenSessionInViewFilter的过滤器，能帮助我们解决懒加载时没有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>

都较瘦 2014-11-09 09:38 发表评论

温故知新:spring_09整合Hibernate

都较瘦 — Sat, 08 Nov 2014 16:37:00 GMT

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

都较瘦 2014-11-09 00:37 发表评论

温故知新:spring_08整合JDBC

都较瘦 — Fri, 07 Nov 2014 13:44:00 GMT

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

都较瘦 2014-11-07 21:44 发表评论

温故知新:spring_07基于XML配置AOP

都较瘦 — Wed, 05 Nov 2014 14:45:00 GMT

相比较于使用annotation去配置，使用XML去配置AOP反而简单些，无需在切面类中为每个通知方法定义切入点表达式，切面类简洁且不受代码入侵，非常的灵活。

切面类，去除掉和AOP有关的注解，变得非常简洁

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("环绕开始切入点：execute==>" + pjp.getTarget() + "==>"
20                 + pjp.getSignature().getName() + " method");
21         pjp.proceed();
22         Logger.info("环绕结束切入点：execute==>" + pjp.getTarget() + "==>"
23                 + pjp.getSignature().getName() + " method");
24     }
25 }
26

beans.xml变更为以下的配置

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>

测试类

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         //基于XML的AOP
15         UserAction ua = (UserAction) factory.getBean("userAction");
16         ua.addUser();
17     }
18
19 }
20

结果和使用annotation无异：

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

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

用户增加方法

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

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

都较瘦 2014-11-05 22:45 发表评论

温故知新:spring_06基于annotation配置AOP

都较瘦 — Wed, 05 Nov 2014 03:09:00 GMT

要使用注解去配置AOP，首先要在spring的配置中开启切面自动代理。

此时，需要加入aop对应的命名空间，虽然搜索一下会有一大堆，但是这种命名空间的声明会在spring-XXX相应的包下找到，要加入aop的声明，可在spring-aop-X.X.X.jar包，META-INF下的spring.schemas，spring.tooling配置文件中找到。
在定义切面之前，还是先理清一些概念
1，切入点（point-cut），核心是切入点表达式，可以确定请求流程中的某一个点。
2，通知（advice），可以理解为在切入点的某个位置（常见如切入点之前，之后，或者环绕着切入点）添加需要拓展的功能，通知包含切入的具体位置和拓展的内容。
3，切面（aspect），一类切入点（比如专门添加日志的切面，或者专门记录异常的切面）可以理解为组成了一个切面，切面包含了切入点和所需要的通知。
下面定义一个切面：

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功能，AOP相关的注解需要添加AspectJ的饮用
14  * @author Administrator
15  *
16  */
17 //注明这是一个切面类
18 @Aspect
19 //添加spring的管理
20 @Component("loggerAspect")
21 public class LoggerAspect {
22     //@Before标注的方法意为将该方法作用于切入点表达式注明的方法之前执行，可以理解为创建一个通知，
23     //关于切入点表达式：execution(* org.duyt.dao.*.add*(..)
24     //第一个*代表着任意类型返回值的方法
25     //之后跟空格，添加一个包的路径，第二个*表示该包路径下的所有类
26     //之后添加“.”，再跟需要切入的方法，此处指定了所有以add,delete,update开头的方法，使用“||”并列连接这些表达式
27     //最后的“(..)”表示任意个数的参数列表
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，获取执行的对象
33         // System.out.println(jp.getSignature().getName());//add，获取方法签名
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("环绕开始切入点：execute==>" + pjp.getTarget() + "==>"
49                 + pjp.getSignature().getName() + " method");
50         pjp.proceed();//执行方法
51         Logger.info("环绕结束切入点：execute==>" + pjp.getTarget() + "==>"
52                 + pjp.getSignature().getName() + " method");
53     }
54 }
55

DAO和Service内容略，测试类如下

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         //基于annotation的AOP
15         UserAction ua = (UserAction) factory.getBean("userAction");
16         ua.addUser();
17     }
18
19 }
20

结果：

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

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

用户增加方法

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

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

都较瘦 2014-11-05 11:09 发表评论

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

都较瘦 — Tue, 04 Nov 2014 15:24:00 GMT

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

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 }

创建代理类，这个代理类的主要作用就是为传入的被代理对象，添加方法执行前的记录日志功能

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     //私有空构造
13     private DaoLoggerProxy(){
14     }
15
16     //工厂方法
17     public static Object getInstance(Object o){
18         DaoLoggerProxy proxy = new DaoLoggerProxy();
19         //保存要代理的对象
20         proxy.target = o;
21         //创建传入对象的代理对象
22         Object result = Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(), proxy);
23         //返回创建的代理对象
24         return result;
25     }
26
27     //被代理对象在调用任何方法的时候，都会先调用代理类的invoke方法，那么在此，就可以在被代理对象方法执行的任意一个流程添加需要的功能
28     public Object invoke(Object proxy, Method method, Object[] args)
29             throws Throwable {
30
31         /*if (method.isAnnotationPresent(XXX.class)) {
32             可以自定义注解给特定方法，规定这些方法执行哪些特殊的操作
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             记录异常的操作，或者回滚操作
43         }*/
44
45         //在被代理对象方法执行之前进行某些操作
46
47         System.out.println("---->模拟记录日志<----");
48         Object obj = method.invoke(target, args);
49
50         //之后进行某些操作
51
52         return obj;
53     }
54
55 }
56

beans.xml需要作出如下配置

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>

配置完毕之后，使用代理注入userDao，@Resource(name = "daoLoggerProxy")，测试

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

结果：

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

用户增加方法

都较瘦 2014-11-04 23:24 发表评论

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

都较瘦 — Tue, 04 Nov 2014 06:57:00 GMT

spring的另一个重要特性是AOP（Aspect Oriented Programming）面向切面的编程，spring的AOP特性使得对于使用了该特性的项目的可维护性，易拓展性和开发难易度等等都有了不同程度的改善。AOP特性能够使得项目中的某些操作，在执行到某一个指定环节的时候，可以额外的去执行开发者指定的操作，这些操作往往都是具有共通性，而且可能和操作本身所包含的业务逻辑没有直接的关系，比如对数据库的访问，涉及变更数据库内容的操作需要精准的记录日志；每当产生异常或者错误信息的时候，也需要记录错误信息；对服务器敏感资源进行访问的时候需要对用户的权限进行校验等。在哪些环节添加处理，做怎样的处理，都可以由开发者自定义，十分灵活，而且在开发业务逻辑和流程的时候大可不必去考虑这些共同性质的处理，让主要精力都投入在业务的实现上，这样一来，开发效率会大大提高。

先从一个静态代理的例子来感受一下这种切入式的编程
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

一个很单纯的接口实现。倘若这就是一个成品了，测试通过没有问题，可以上线使用。一段时间之后，需要加入日志的功能，那么问题来了，挖掘机哪...噢不对，该如何添加呢？
或许会马上想到，直接该啊。那么问题又来了，挖...噢不，直接修改的话，代码就需要测试，而且万一需要修改的地方很多呢，岂不是很痛苦，况且直接修改源代码还违背了OCP原则，绝对不推荐。这时候就可以考虑使用代理类来给源代码增加新功能。
代理，望文生义，白话就是“你要做的事儿我不仅能给你做了，而且除此之外我还能多做别的”，定义一个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("使用代理，为用户增加方法添加日志");
19         userDao.add();
20
21     }
22
23 }
24

在代理中，将需要拓展功能的对象作为代理的属性注入，然后在需要拓展的方法前后追加需要的功能。在此之后，在给service的IuserDao对象注入实例的时候，要使用代理的对象@Resource(name = "userProxyDao")，测试一下

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

结果：

使用代理，为用户增加方法添加日志

用户增加方法

由于IOC和AOP的特性，你会发现你要做的更改十分的少，仅仅只是新增了一个代理类，并修改了注入的对象。虽然静态的代理可以实现我们的需求，但是毕竟不灵活，一旦修改涉及的方法和类一多，那简直就是纯体力活了，一个类的拓展就需要对应一个代理类，一个代理类中还需要涵盖所有需要拓展的方法，并且保证原有功能不受影响，如此一来，功能拓展这一举动就需要投入极大的成本，入不敷出。

都较瘦 2014-11-04 14:57 发表评论

温故知新:spring_03基于annotation配置IOC

都较瘦 — Tue, 04 Nov 2014 03:17:00 GMT

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

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组件的注入为例

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的实现

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类相当于在配置文件中写作
8 //
9 @Repository("userDao")
10 //相应的，Scope("singleton")标注就相当于的配置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提供了三种注解来对应MVC的三层，数据层的注解对应Repository，业务层对应service，表示层对应controller。还有一个公共的component，分开这么多是为了更好的标注当前这个待注入类的功能，如果不按照这些分类好的注解去注入也可以完成注入，但是还是规范的去写。关于对象中某个属性的注入看下面的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略
30 }
31

对于某个要注入的属性，Spring自带的注解是@AutoWire，但是这种是按照类型注入的，为了避免接口多实现可能出现的问题，推荐可以使用javax.annotation提供的@resource，这种是按照属性的名称进行注入，可以直接在属性名之上添加注解，这样的话连属性的get/set都可以省了...或者是添加对应的get/set，在set方法上添加注解。但是要注意的是，按照属性名字进行注入，属性的名称需要和注解定义组件时的id一致。Action中的Iuserservice的实例名为userService，会寻找有@service("userService")的注解进行注入，否则会注入失败。
测试如下

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

结果为：

false

用户增加方法

都较瘦 2014-11-04 11:17 发表评论

温故知新:spring_02基于XML配置IOC

都较瘦 — Mon, 03 Nov 2014 14:46:00 GMT

第一个案例已经是基于XML配置spring的工厂了，那么现在，正了八景的配置一下。

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

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 }

实体类

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略
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略
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略
9 }
10

重点是beans.xml的配置

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="测试用字符串AAA"/>
22         <constructor-arg name="testStringB" value="测试用字符串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         //测试使用构造方法进行注入
17         System.out.println(ua.getTestStringA());
18         System.out.println(ua.getTestStringB());
19         //属性注入
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

都较瘦 2014-11-03 22:46 发表评论

温故知新:spring_01IOC整体感受

都较瘦 — Mon, 03 Nov 2014 09:19:00 GMT

IOC（inverse of control）控制反转，是spring提供的非常优秀的一种特性，这种特性使得在项目中，所有对象的实例都交由spring去创建，管理。为什么要这么做呢，假使我们脱离spring，在开发的过程中，需要新建实例的时候自己去new，那么组件之间的耦合度会非常高，在一个业务处理类中，某个对象就写死引用某个实例，一旦有较大的业务变更，需要修改的地方可能会多的不敢想象，如果文档，代码和注释的维护较差，那么业务变更简直就是噩梦。spring的IOC特性就助力实现了“高内聚，低耦合”的这种设计理念。
记录一下平时在使用spring时的一些技巧和心得，先说明一下测试环境。

环境如下
系统：64位win7

测试环境：

先从一个helloworld的简单案例开始吧
新建一个maven项目，选择

其实不论使用哪个框架技术，都无非三步走，import，config，run，首先，我们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>

之后，我们开始config，作为一个基本IOC演示，只需要定义工厂的配置。定义一个beans.xml文件，置于src下。其中bean标签就是定义beanId和待注入对象实例之间的映射。
就是“用这个id取对象实例，你会取到class的对象实例”

演示类

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

测试类

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     //读入指定的工厂配置文件到spring的容器，文件名可自定义
11     private BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");
12
13     @Test
14     public void test(){
15         //根据bean的key获取对象的实例
16         Demo d = (Demo) factory.getBean("helloSpring");
17         //或者直接使用重载的getBean方法，设定好需要返回的类型
18         //Demo dd =  factory.getBean("helloSpring", Demo.class);
19         d.hello();
20         //dd.hello();
21     }
22
23 }
24

以上，就是spingIOC最简易的使用。

都较瘦 2014-11-03 17:19 发表评论