Spring3

Spring 3.x

  1. Weblogic - 分层,基于j2ee,服务器
  2. IOC: 通过配置,解决了高内聚低耦合的问题
  3. AOP: 例如日志文件,每个对象都要设计对应代码,aOP则将之变为公共切面, 每次需要调用写日志功能时,就通过拦截方式,对其进行处理
  4. Transaction:
  5. Spring取代EJB

IOC

面向接口->引入工厂->配置文件

Spring提供IOC容器,相当于一个工厂

DI

Dependency Injection

实例化Bean方式

  1. 类构造器实例化(默认无参数)
  2. 静态工厂
  3. 动态工厂

Bean的作用域

  1. singleton 单例
  2. prototype 每次返回新实例
  3. request 每次http请求都会创建新的
  4. session 同一个http session共享一个
  5. globalSession 用于portlet环境

Setter方法注入

集合类型属性注入

  1. list,set,map,properties

AOP

Aspect Oriented Programming

OOP的延伸,OOP纵向集成,AOP横向抽取(性能监视,事务管理,安全检查,缓存)

两种实现方式

SpringAOP 不需要专门的编译过程和类加载,在运行期间通过代理方式向目标类织入(Weaving)增强代码

AspectJ:基于JAVA+AOP的框架(自己定义AOP切面)

Aspect

代理

  1. 动态代理
    1. 用户手动编写代理类,对目标类代理
      1. JDK动态代理、 Javassist 动态 代理 、 Cglib 动态代理,Spring 底层使用 JDK动态代理 + Cglib 动态代理
  2. 静态代理
    1. 在虚拟机内部动态构造

JDK动态代理

@Test
public void demo2() {
    // 对目标进行代理
    IUserService target = new UserServiceImpl(); // 获得目标
    // 构造代理工厂
    JdkProxyFactory factory = new JdkProxyFactory(target);
    // 通过工厂创建代理
    IUserService proxy = (IUserService) factory.createProxy();

    proxy.login();
}


public class JdkProxyFactory implements InvocationHandler {

    // 被代理目标对象
    private Object target;

    public JdkProxyFactory(Object target) {
        this.target = target;
    }

    // 创建代理对象
    public Object createProxy() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    // 拦截目标对象，执行invoke方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("执行代理...");
        return method.invoke(target, args);
    }
}

CGLIB动态代理

对于不使用接口的业务类，无法使用JDK动态代理

CGlib采用非常底层字节码技术，可以为一个类创建子类，解决无接口代理问题

JDK+Spring AOP配置的代理方法

Advice

public class MyAroundAdvice implements MethodInterceptor {

    @Override
    /**
     * 记录方法运行时间
     */
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = methodInvocation.proceed();
        long end = System.currentTimeMillis();
        System.out.println("方法运行时间：" + (end - start));
        return result;
    }
}

applicationContext.xml

    <!-- 自定义Advice -->
    <bean id="myaroundAdvice" class="bupt.spring.c_aop.MyAroundAdvice" />
    <bean id="myAspect" class="bupt.spring.d_aspectj.MyAspect" />
    <!-- 对目标进行AOP代理 -->
    <aop:config proxy-target-class="true">
        <!-- 
            aop:advisor Spring1.2传统意义上切面 ，只支持一个Pointcut切点和一个Advice通知
            aop:aspect Spring2.0后整合 AspectJ框架定义切面，可以支持多个Pointcut切点和多个Advice通知
            aop:pointcut 根据AspectJ规则定义切点 
         -->
         <aop:advisor advice-ref="myaroundAdvice" 
            pointcut="execution(* bupt.spring.c_aop.CustomerServiceImpl.*(..))"/>
    <!--(..)表示所有的参数-->
    </aop:config>

 通过execution函数，可以定义切点的方法切入

AspectJ

Transaction

事务管理高层抽象主要包括三个接口

  1. PlatformTransactionManager 事务管理器
    1. getTransaction(TransactionDefinition):TransactionStatus
    2. commit
    3. rollback
  2. TransactionDefinition 事务定义信息(隔离、传播、超时、只读)
  3. TransactionStatus 事务具体运行状态
    1. isNewTransaction():boolean
    2. hasSavePoint():boolean
    3. isRollbackOnly():boolean
    4. setRollbackOnly():void
    5. flush
    6. isCompleted

Spring为不同持久化框架提供了不同PlatformTransactionManager实现

四种事务隔离级别

  1. DEFAULT
    1. 根据各数据库不同
  2. READ_UNCOMMITED
    1. 脏读,幻读,不可重复读
  3. READ_COMMITED
    1. 幻读,不可重复读
  4. REPEATABLE_READ
    1. 幻读
  5. SERIALIZABLE
    1. 最慢,完全锁定数据

七种事务传播行为

  1. PROPAGATION_REQUIRED
  2. PROPAGATION_SUPPORTS
  3. PROPAGATION_MANDATORY
  4. PROPAGATION_REQUIRED_NEW
  5. PROPAGATION_NOT_SUPPORTED
  6. PROPAGATION_NEVER
  7. PROPAGATION_NESTED

事务传播行为

当一个业务层代码，去调用另一个业务层代码，当被调用方 发生异常，调用方代码是提交还是回滚，这就可以通过事务 传播行为进行控制.