Spring（二）——aop面向切面

一.Spring的bean管理(注解方式)

注解介绍
1.代码里面的一些特殊的标记.使用注解可以完成相关功能
2.注解写法@注解的名称(属性名称=属性值)
3.注解可以使用在类上面,方法上面 和 成员变量上

spring开发准备
1.导入jar包
(1)导入spring基本jar包



(2)导入aop包



2.创建类,创建方法
3.创建spring配置文件,引入约束
(1)beans约束
(2)ioc,注解约束



4.开启注解的扫描

<!-- 开启注释扫描 -->
<context:component-scan base-package="anno"></context:component-scan>

注解创建对象
4000
1.在创建对象的类上面使用注解实现
（1）

@Component(value="user") // <bean id ="user" class=""/>public class User {}
（2）

ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
User user=(User)context.getBean("user");
user.add();

2.创建对象有四个注解



(1)@Component
(2)@Controller
(3)@Service
(4)@Repository
目前四个注解功能是一样的,都用来创建对象

3.创建对象单实例还是多实例
@Component(value="user" ) // <bean id ="user" class=""/>
@Scope(value ="prototype")
注解注入属性
1.创建service类，创建dao类，在service中得到dao对象
输入第一个注解@Autowired（通过类去找，和value没有关系）
@Resource（通过 name去找）
（1）创建service类，创建dao类

@Service(value = "userservice")
public class Userservice {

@Component(value = "userdao")
public class UserDao {

（2）在service里面定义dao类型属性

@Service(value = "userservice")
public class Userservice {

@Component(value = "userdao")
public class UserDao {

配置文件和注解混合使用的方式
1.创建对象使用配置文件方式
<bean id="bookservice" class="mix.BookService"></bean>
<bean id="bookdao" class="mix.BookDao"></bean>
<bean id="ordersdao" class="mix.OrdersDao.ordersDao()"></bean>
2.注入属性使用注解的方式
//得到bookdao和ordersdao
@Resource(name="ordersdao")
private OrdersDao OrdersDao;

@Resource(name="bookdao")
private BookDao BookDao;

二、AOP

aop概念
1.AOP：面向切面编程，扩展功能不通过修改源代码实现
2.AOP采取横向抽取机制，取代了传统纵向继承机制
aop原理





aop操作术语
joinpoint（连接点）：类里面可以被增强的方法，这些方法就称为连接点。
Pointcut（切入点）：就是实际操作中被增强的方法，就成为切入点
advice（通知/增强）；实际增强的逻辑，称为增强或者通知，例如扩展日志功能，这个日志功能就成为增强。
通知分为前置通知:在方法之前执行
后置通知，在方法之后执行
异常通知，方法出现了异常执行
最终通知，在后置之后执行
环绕通知：在方法之前之后执行
aspect（切面）：把增强应用到具体的方法上面，这个过程称为切面
把增强用到切入点的过程
Introduction（引介）：
target（目标对象）：增强方法所在类叫做目标对象
Weaving（织入）：把增强应用到目标的过程

把advice 应用到target的过程
proxy（代理）：一个类AOP织入增强后，就产生一个结果代理类

三、Spring的aop操作
1.spring里面进行aop操作，使用aspectj
（1）aspectj不是spring一部分，和spring一起实现spring
（2）spring 2.0后增加了aspectj的支持
2使用aspectj实现aop方式
（1）使用aspectj的xml方式
（2）使用aspectj的注解方式

（1）使用aspectj的xml方式

准备工作

导入aop相关的jar包



使用表达式配置切入点
1.切入点，实际增强的方法

2.配置切面，把增强用到方法上面

bean.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> 
<!-- 1.配置两个对象 -->
<bean id="book" class="aopDemo.Book"></bean>
<bean id="bookaddition" class="aopDemo.BookAddition"></bean>

<!-- 2.配置aop操作 -->
<aop:config>
<!-- 2.1配置切入点 -->
<aop:pointcut expression="execution(* aopDemo.Book.*(..))" id="pointcut1"/>
<!-- 2.2配置切面 把增强用到方法上面 -->
<aop:aspect ref="bookaddition">
<!-- 增强类型 method：增强类里面使用哪个方法作为前置增强 -->
<aop:before method="before1" pointcut-ref="pointcut1"/>
<!-- 后置通知 -->
<aop:after method="after1" pointcut-ref="pointcut1"/>
<!-- 环绕通知 -->
<aop:around method="arround1" pointcut-ref="pointcut1"/>
</aop:aspect>
</aop:config>
</beans>

（2）基于aspectj的注解方式aop

准备工作
导入aop相关的jar包



上面的方法，虽然可行，但是需要在bean文档中写大量文字，也不是很方便，
注解的方法会渐变很多：
1.切入点，实际增强的方法
2.常用的表达式——用于advice上面
excution（<访问修饰符>？<返回类型><方法名>（<参数>）<异常>）
（1）excution(* aopDemo.Book.add(..))
（2）excution(* aopDemo.Book.*(..))
（3）excution(* *.*(..))
增强方法：
需要作为增强的方法前面加上注解@Before（value=“excution（<访问修饰符>？<返回类型><方法名>（<参数>）<异常>）”）

package aopDemo2;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class BookAddition {

@Before(value="execution(* aopDemo2.Book.*(..))")
public void before1(){
System.out.println("before..");
}
//后置增强
@After(value="execution(* aopDemo2.Book.*(..))")
public void after1(){
System.out.println("after..");
}
//环绕通知
@Around(value="execution(* aopDemo2.Book.*(..))")
public void arround1(ProceedingJoinPoint proceedingJoinPoint ) throws Throwable{
//前置方法
System.out.println("方法之前环绕。。。");
//执行被增强的方法
proceedingJoinPoint.proceed();
//后置方法
System.out.println("方法之环绕。。。");
}

}

被增强方法：

package aopDemo2;

public class Book {
public void add(){
System.out.println("book..");
}

}

测试方法（主方法）：

package aopDemo2;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Testaop {
@Test
public void testService(){
ApplicationContext context = new ClassPathXmlApplicationContext("aopDemo2/beans.xml");
Book book = (Book) context.getBean("book");
System.out.println(book);
book.add();
}
}

完成了在增强方法中的注解后，bean文件就很简单了，如同我们进行ioc的时候一样，只需要这一行代码就可以了
这行开启aop代理，进行class对象的扫描
bean文件中：

<!-- 1.配置两个对象 -->
<bean id="book" class="aopDemo.Book"></bean>
<bean id="bookaddition" class="aopDemo.BookAddition"></bean>
<!-- 2.开启aop代理 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

这个时候我们在Testaop上面 通过junit运行可以看到：



这里样我们的方法 Book.add() 就通过注解方式增强了