Spring学习day02

一、Spring用注解代替xml配置

1、为主配置文件引入新的命名空间（约束）——/schema/context

2、开启使用注解代理配置文件

 //domain及其子孙包是需要进行注解扫描的基础包

<context:component-scan base-package="domain"><context:component-scan> 

3、在类中完成注解配置

@component("user")

//<bean name="user" class="domain.user"></bean>

//@Service("user")：标识service层

//@Controller("user")：标识web层（Servlet、action等）

//@Repository("user")：标识dao层

//指定对象的作用范围，默认singleton

@Scope(scopeName="prototype")

public class User{

}

4、值类型注入：

@Value("tom")     //通过反射的Field进行赋值，破坏了Java的封装性

    private String name;

    /*@Value("tom")    //通过set方法进行赋值，但略麻烦

    public void setName(String name){

        this.name=name;

    }*/

5、引用类型注入

//@Autowired //自动装配，当且仅当容器内只有一个类型匹配的对象时

//@Qualifier("car2")   //当匹配的对象多于1个时，自动匹配name=car2的对象，与@Autowired配合使用

@Resource(name="car2")：手动注入，指定注入哪个名称的对象，推荐使用

private Car car;

6、初始方法和销毁方法

@PoseConstruct    //在对象被创建后调用，init-method

public void init(){}

@PreDestroy    //在销毁之前调用，destroy-method

public void destroy(){}

二、STS插件安装

对于eclipse，需要安装Spring-tool-suite插件辅助提示功能。

三、Spring整合Junit测试

1、导包：spring-test

2、配置

@RunWith(SprintJunit4ClassRunner.class)    //帮我们创建容器

@ContextConfiguration("classpath:applicationContext.xml")    //指定创建容器时使用哪个配置文件

public class Demo{

    @Resource("user")

    private User user;

    @Test

    public void fun(){

        System.out.println(user);

    }

}

四、AOP思想介绍

AOP：Aspect Oriented Programming：面向切面编程

AOP思想总结：纵向重复，横向抽取。

之前遇到AOP的情况：filter，动态代理，interceptor。

五、AOP实现原理——动态代理&&CGlib代理

1、动态代理

动态代理针对的是共用接口的情况，即代理类与原类共用接口，二者没有其他关系。

动态代理核心方法：

Proxy.newProxyInstance(classLoader, interface[] arr, InvocationHandler handler)

// UserServiceFactory 实现了InvocationHandler接口，UserService即

eg:UserService usProxy = (UserService) new Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader, UserServiceImpl.class.getInterfaces(),  this)

动态代理需要之后在UserServiceProxyFactory中实现invoke()方法。

public Object invoke(Object arg0, Method method, Objects[] arg2 ){

    System.out.println("前处理");

    Object invoke = method.invoke(us, arg2);  //us是需要增强的类

    System.out.println("后处理");

    return invoke;

}

2、CGlib

CGlib应用的场景是当需要代理的对象是类而不是接口时。它的解决方法是利用继承来生成代理对象。

六、Spring的AOP名词解释

Jointpoint（连接点）：目标对象中，所有可以增强的方法

Pointcut（切入点）：目标对象中，已经增强的方法。

Advice（通知/增强）：增强的代码，包括前处理和后处理

Target（目标对象）：被代理的对象

Weaving（织入）：将Advice应用到PointCut中的过程

Proxy（代理）：将Advice织入目标对象后，形成代理对象

Aspect（切面）：PointCut+Advice

Introduction(引介)：引介是一种特殊的通知，在不修改类代码的前提下, Introduction 可以在运行期为类
动态地添加一些方法或 Field。

七、Spring的AOP

1、导包：包括Spring的两个aop包（spring-aspects，spring-aop）和第三方的两个aop包（org.aopalliance、org.aspectj.weaver）

2、准备目标对象，即UserServiceImpl。

3、准备通知（Advice）

（1）前置通知：目标方法运行之前通知

（2）后置通知：在目标方法运行之后通知，如果出现异常不会调用

（3）后置通知：在目标方法运行之前通知，如果出现异常也会调用

（4）环绕通知：在目标方法运行之前与之后都会调用

（5）异常拦截通知：如果出现异常，就会调用

publc void before(){

    System.out.println("这是前置通知");

}

public void afterReturning(){

    System.out.println("这是后置通知（如果出现异常不会调用）");

}

public void after(){

    System.out.println("这是后置通知（如果出现异常也会调用）");

}

public Object round(ProceedingJointPoint pjp) throws Throwable{

    System.out.println("这是环绕通知之前的部分");

    Object proceed = pjp.proceed();

    System.out.println("这是环绕通知之后的部分");

}

public void afterException(){

    System.out.println("出现异常！");

}

4、配置进行织入，将通知织入到目标对象中

（1）首先引入新的命名空间（约束）：spring-aop
（2）配置目标对象（UserServiceImpl）和通知对象（MyAdvice）。

（3）配置将通知织入目标对象

xml配置方式：

<aop:config expresstion="execution(* domain.*ServiceImpl.*(..))" id="pc">   //domain包下返回值可为任意的后缀名为ServiceImpl的类的所有方法。

<aop:aspect ref="MyAdvice">

    <aop:before method="before" pointcut-ref="pc">  //前置

    <aop:after-returning method="afterReturning" pointcut-ref="pc">  //后置（有异常不运行）

    <aop:around method="round" pointcut-ref="pc">  //环绕通知

    <aop:after-throwing method="afterException" pointcut-ref="pc">  //异常拦截通知

    <aop:after method="after" pointcut-ref="pc">//后置（有异常也运行）

</aop:config>

注解方式：

在applicationContext.xml中开启注解配置：

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

在MyAdvice中利用注解进行配置：

@Aspect

//表示该类是一个通知（Advice）类

public class MyAdvice{

    @Pointcut("execution(* domain.*ServiceImpl.*(..))")

    public void pc(){}

    @Before("MyAdvice.pc()")

    publc void before(){

         System.out.println("这是前置通知");

     }

    @AfterReturning("MyAdvice.pc()")

     public void afterReturning(){

         System.out.println("这是后置通知（如果出现异常不会调用）");

     }

    @After("MyAdvice.pc()")

     public void after(){

         System.out.println("这是后置通知（如果出现异常也会调用）");

     }

    @Round("MyAdvice.pc()")

     public Object round(ProceedingJointPoint pjp) throws Throwable{

         System.out.println("这是环绕通知之前的部分");

         Object proceed = pjp.proceed();

         System.out.println("这是环绕通知之后的部分");

     }

    @AfterThrowing("MyAdvice.pc()")

     public void afterException(){

         System.out.println("出现异常！");

     }

}