1.使用注解配置spring

1.1 引入新的命名空间（约束）

如果是使用eclipse的同学，那么肯定是很熟悉这个了。使用idea的话，就不需要自己引入了，idea已经将约束添加好了

1.2 在spring的配置文件中开启注解

<!--指定扫面 bean 包下的所有类 的注解-->
    <context:component-scan base-package="bean"/>

1.3 在类中使用注解

// 相当于在xml配置文件中写<bean name="user" class="bean.user" />
@Component("user") // 早期使用，当初只有component，后续细化出了下面三个，用于不同的层，方便阅读
    @Service("user")    // service层
    @Controller("user") // web层
    @Repository("user") // dao层

1.4 测试

@Test
    public void testFunc01() {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        User user = (User) applicationContext.getBean("user");

        System.out.println(user);
    }

2. 使用注解

2.1 使用Scpoe

@Repository("user") // dao层
@Scope("prototype")
public class User {
    private String name;
    private Integer age;
    private Dog dog;

2.2 基本数据类型赋值

1. 在属性上赋值
   通过反射的field赋值，破坏封装性，但是可读性好

public class User {
    @Value("tom")
    private String name;

    @Value("18")
    private Integer age;

2. 在set方法上赋值
   在set方法赋值，推荐使用，但是可读性不太好

@Value("tom")
    public void setName(String name) {
        this.name = name;
    }

    @Value("18")
    public Integer getAge() {
        return age;
    }

2.3 引用类型赋值

先给dog类赋值

@Component("dog")
public class Dog {

    @Value("柯基")
    private String name;
    @Value("3")
    private Integer age;

1. 手动注入，指定注入哪个名称的对象

    @Resource(name = "dog")
    private Dog dog;

2. @Autowired 自动装配
   问题：如果发现多个类型一致的对象，将无法选择具体注入哪一个对象
   如果需要指定注入某一个对象，需要添加辅助注解

在User 中只需要添加注解

    @Autowired
    @Qualifier("dog2")
    private Dog dog;

2.4 创建和销毁注解

@PostConstruct // 在对象创建后调用，相当于init-method
    public void init() {
        System.out.println("初始化方法调用");
    }

    @PreDestroy // 在对象销毁之前调用，相当于destroy-method
    public void destroy() {
        System.out.println("销毁方法调用");
    }

3. spring junit整合测试

这样就不需要在每个测试方法中都重复书写获取对象的代码

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

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

    @Resource(name = "user")
    private User user;

    @Test
    public void testFunc01() {

        System.out.println(user);
    }
}

4. spring aop

4.1 aop 名词

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

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

3. Advice（通知/增强）：增强的代码。（例如：打开事务，关闭事务）

4. Target（目标对象）：被代理对象

5. Weaving（织入）：将通知应用到连接点的过程

6.Proxy（代理）：将通知织入到目标对象之后，形成代理对象

7.Aspect（切面）：切入点+通知

4.2 配置将通知织入目标对象

1. 准备一个通知类

/// 通知类
public class MyAdvice {
    public MyAdvice() {
    }

    // 前置通知 -》目标方法调用之前调用
    public void before() { System.out.println("这是前置通知"); }

    // 后置通知（如果出现异常不会调用）-》在目标方法调用之后调用
    public void afterReturning() { System.out.println("这是后置通知"); }

    // 环绕通知 -》在目标方法调用之前和之后都调用
    public Object around(ProceedingJoinPoint pjp) throws Throwable {

        // 调用目标方法
        System.out.println("这是环绕通知前部分");
        Object proceed = pjp.proceed();
        System.out.println("这是环绕通知后部分");
        return proceed;
    }

    // 异常拦截通知 -》如果出现异常会调用
    public void afterException() {
        System.out.println("这是异常拦截通知");
    }

    // 后置通知（如果出现异常仍会调用）-》在目标方法调用之后调用
    public void after() {
        System.out.println("这是后置通知-出现异常仍会调用");
    }

}

2. 配置通知对象和通知方法

 <!--配置目标对象-->
    <bean name="userService" class="service.UserServiceImpl"></bean>

    <!--配置通知对象-->
    <bean name="myAdvice" class="springAop.MyAdvice"></bean>

    <!--配置将通知织入目标对象-->
    <!--
        public void service.UserServiceImpl.save()
        void service.UserServiceImpl.save()
        * service.UserServiceImpl.*()
        * service.*ServiceImpl.*(..)
    -->
    <aop:config>
        <aop:pointcut expression="execution(* service.*ServiceImpl.*(..))" id="pc"/>

        <aop:aspect ref="myAdvice" >
            <!-- 指定名为before方法作为前置通知 -->
            <aop:before method="before" pointcut-ref="pc" />
            <!-- 后置 -->
            <aop:after-returning method="afterReturning" pointcut-ref="pc" />
            <!-- 环绕通知 -->
            <aop:around method="around" pointcut-ref="pc" />
            <!-- 异常拦截通知 -->
            <aop:after-throwing method="afterException" pointcut-ref="pc"/>
            <!-- 后置 -->
            <aop:after method="after" pointcut-ref="pc"/>
        </aop:aspect>

    </aop:config>

3.进行测试

// 帮我们创建容器
@RunWith(SpringJUnit4ClassRunner.class)
// 指定创建容器使用哪一个配置文件
@ContextConfiguration("classpath:springAop/applicationContext.xml")
public class Test03 {

    @Resource(name = "userService")
    private UserService us;

    @Test
    public void testFunc01() {

        us.save();
    }
}

4. 结果输出

   
   Snip20180802_16.png

4.3 使用注解配置 将通知织入目标对象

1.在配置文件中开启自动代理

<aop:aspectj-autoproxy/>

2.在通知类中进行配置

/// 通知类
@Aspect
public class MyAdvice {

    @Pointcut("execution(* service.UserServiceImpl.*(..))")
    public void pc() {}

    // 前置通知 -》目标方法调用之前调用
    @Before("MyAdvice.pc()")
    public void before() { System.out.println("这是前置通知"); }

    // 后置通知（如果出现异常不会调用）-》在目标方法调用之后调用
    @AfterReturning("MyAdvice.pc()")
    public void afterReturning() { System.out.println("这是后置通知 （如果出现异常不会调用）"); }

    // 环绕通知 -》在目标方法调用之前和之后都调用
    @Around("MyAdvice.pc()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {

        // 调用目标方法
        System.out.println("这是环绕通知前部分");
        Object proceed = pjp.proceed();
        System.out.println("这是环绕通知后部分");
        return proceed;
    }

    // 异常拦截通知 -》如果出现异常会调用
    @AfterThrowing("MyAdvice.pc()")
    public void afterException() {
        System.out.println("这是异常拦截通知");
    }

    // 后置通知（如果出现异常仍会调用）-》在目标方法调用之后调用
    @After("MyAdvice.pc()")
    public void after() {
        System.out.println("这是后置通知（如果出现异常仍会调用）");
    }

}