spring注解、aop（二）

使用注解配置spring

　　1.导入 spring-aop-5.0.6.RELEASE.jar包

　　2.为主配置文件引入新的命名空间 xmlns:context="http://www.springframework.org/schema/context"

<?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"

       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-4.0.xsd">

    <!--指定扫描com.david.bean下的所有包所有类中的注解 -->

    <context:component-scan base-package="com.david.bean"></context:component-scan>

</beans>

　　3.在类中使用注解

@Component("user")

//相当于<bean name="user" class="com.david.bean.User" />

public class User {

    private String name;

    private Integer age;

    private Car car;

    ...

}

注解后来又出现了三种，可以体现层级关系

@Component("user")

@Service("user") //service层

@Controller("user") //web层

@Repository("user") //dao层

指定作用范围

@Component("user")

//相当于<bean name="user" class="com.david.bean.User" />

@Scope(scopeName = "prototype")

//相当于<bean name="user" class="com.david.bean.User" scope="prototype"></bean>

值类型注入

public class User {

    @Value("david") //字段注入 破坏了封装性

    private String name;

    private Integer age;

    private Car car;

    @Value("18") //set方法注入 推荐使用

    public void setAge(int age) {

        this.age = age;

    }

    ...

}

引用类型（对象）注入

@Component("car")

public class Car {

    @Value("奥拓")

    private String name;

    @Value("red")

    private String color;

    ...

}

@Component("user")

public class User {

    @Autowired //自动装配 对象注入

    private Car car;

    ...

}

@autowired 自动装配的方式如果匹配到多个类型一致的对象，无法选择具体注入哪一个对如：

    <bean name="car2" class="com.david.bean.Car">

        <property name="name" value="奥迪"></property>

        <property name="color" value="black"></property>

    </bean>

此时需要使用@Qualifier("car2")注解告诉容器具体注入哪个对象和@autowired一起使用

    @Autowired

    @Qualifier("car2")

    private Car car;

上面这种要使用两个注解，还有一个注解@Resource 可以手动指定注入哪个对象

    @Resource(name="car2") //手动指定

    private Car car;

初始化和销毁

public class User {

    ...

    @PostConstruct //相当于init-method 对象创建后调用

    public void init(){

        System.out.println("init");

    }

    @PreDestroy //销毁前调用 相当于destory-method

    public void destory(){

        System.out.println("destory");

    }

    ...

}

aop：面向切面编程，是对oop面向对象编程的补充和完善。

spring中的aop

　　spring能够为容器中管理的对象生成动态代理对象。

spring实现aop的原理

　　1.动态代理(优先使用)

　　　　被代理对象必须要实现接口，才能产生代理对象，如果没有接口将不能使用动态代理技术

　　2.cglib代理(没有接口时)

　　　　第三方代理技术，可以对任何类生成代理对象。代理的原理是对目标对象进行继承代理

spring AOP 名词解释：

　　1.Joinpoint连接点：目标对象中，所有可以增强的方法。（可以增强的方法）如：UserServiceImpl implements UserService 中实现的方法 save() delete()

　　2.Pointcut切入点：目标对象中，已经增强的方法。（已增强的方法）如：已通过代理增强的save() 或delete() 可以单独指定某些增强或不增强。

　　3.Advice通知/增强：需要增强的代码。（代理对象调用目标方法前后执行的代码）如：//前增强 method.invoke(us,arg) //后增强。

　　4.Target目标对象：被代理对象。如UserServiceImpl。

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

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

所以进行AOP编程的关键就是定义切入点和定义增强处理，一旦定义了合适的切入点和增强处理，AOP框架将自动生成AOP代理，即：代理对象的方法=增强处理+被代理对象的方法。

基于spring的aop实现

1.导包 aopalliance.jar aspectjweaver.jar　　spring aop需要这两个包的支持下载地址：

http://www.java2s.com/Code/Jar/a/Downloadaopalliancejar.htm

http://www.java2s.com/Code/Jar/a/Downloadaspectjweaverjar.htm

2.准备目标对象

　　先定义一个接口

public interface IHelloWorld {

    void printHelloWorld();

    void doPrint();

}

　　在定义两个接口实现类

public class HelloWorldImpl1 implements IHelloWorld

{

    public void printHelloWorld()

    {

        System.out.println("Enter HelloWorldImpl1.printHelloWorld()");

    }

    public void doPrint()

    {

        System.out.println("Enter HelloWorldImpl1.doPrint()");

        return ;

    }

}

public class HelloWorldImpl2 implements IHelloWorld{

    public void printHelloWorld()

    {

        System.out.println("Enter HelloWorldImpl2.printHelloWorld()");

    }

    public void doPrint()

    {

        System.out.println("Enter HelloWorldImpl2.doPrint()");

        return ;

    }

}

3.准备通知

package com.david.bean;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAdvice {

    //前置通知-目标方法调用之前调用

    public void before() {

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

    }

    //后置通知-目标方法之后调用，如果异常不会调用

    public void afterRuning() {

        System.out.println("后置通知，出现异常不会调用");

    }

    //环绕通知-在目标方法之前和之后都调用

    public void around(ProceedingJoinPoint pjp) throws Throwable {

        System.out.println("环绕前通知");

        Object proceed = pjp.proceed();//调用目标方法

        System.out.println("环绕后通知");

    }

    //异常通知-如果出现异常就会被调用

    public void afterException(){

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

    }

    //后置通知-目标方法之后调用，无论异常与否都会调用

    public void after() {

        System.out.println("后置通知，无论异常与否都会调用");

    }

}

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

新建一个aop.xml

<?xml version="1.0" encoding="UTF-8"?>

<!--导入aop命名空间 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

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

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

    <!--配置目标对象 -->

    <bean id="helloWorldImpl1" class="com.david.bean.HelloWorldImpl1" />

    <bean id="helloWorldImpl2" class="com.david.bean.HelloWorldImpl2" />

    <!--配置通知对象 -->

    <bean id="myAdvice" class="com.david.bean.MyAdvice" />

    <!--配置将通知织入目标对象 -->

    <aop:config>

        <!--配置切入点:所有方法都增强 -->

        <aop:pointcut id="allMethod" expression="execution(* com.david.bean.IHelloWorld.*(..))"></aop:pointcut>

        <aop:aspect id="advice" ref="myAdvice">

            <!--通知方法 -->

            <aop:before method="before" pointcut-ref="allMethod" />

            <aop:after-returning method="afterRuning" pointcut-ref="allMethod"></aop:after-returning>

            <aop:around method="around" pointcut-ref="allMethod"></aop:around>

            <aop:after method="after" pointcut-ref="allMethod" />

        </aop:aspect>

    </aop:config>

</beans>

5.编写测试类

    public static void main(String[] args) {

        ApplicationContext ac = new ClassPathXmlApplicationContext("aop.xml");

        IHelloWorld hw1 = (IHelloWorld)ac.getBean("helloWorldImpl1");

        IHelloWorld hw2 = (IHelloWorld)ac.getBean("helloWorldImpl2");

        hw1.printHelloWorld();

        System.out.println();

        hw1.doPrint();

        System.out.println();

        hw2.printHelloWorld();

        System.out.println();

        hw2.doPrint();

    }

使用spring aop开发就不需要我们手写动态代理代码了，还封装了cglib代理。可以对任何类进行代理增强。

spring的aop注解配置

<?xml version="1.0" encoding="UTF-8"?>

<!--导入aop命名空间 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

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

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

    <!--配置目标对象 -->

    <bean id="helloWorldImpl1" class="com.david.bean.HelloWorldImpl1" />

    <bean id="helloWorldImpl2" class="com.david.bean.HelloWorldImpl2" />

    <!--配置通知对象 -->

    <bean id="myAdvice" class="com.david.bean.MyAdvice" />

    <!--开启使用注解织入目标对象 -->

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

</beans>

通知类使用注解设置

@Aspect //表示该类是一个通知类

public class MyAdvice {

    @Before("execution(* com.david.bean.IHelloWorld.*(..))") //是一个前置通知并指定切入点

    public void before() {

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

    }

    @After("execution(* com.david.bean.IHelloWorld.*(..))")

    public void after() {

        System.out.println("后置通知，无论异常与否都会调用");

    }

    @AfterReturning("execution(* com.david.bean.IHelloWorld.*(..))")

    public void afterRuning() {

        System.out.println("后置通知，出现异常不会调用");

    }

    @Around("execution(* com.david.bean.IHelloWorld.*(..))")

    public void around(ProceedingJoinPoint pjp) throws Throwable {

        System.out.println("环绕前通知");

        Object proceed = pjp.proceed();//调用目标方法

        System.out.println("环绕后通知");

    }

}

再次运行效果一样的。抽取切入点

package com.david.bean;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.*;

@Aspect //表示该类是一个通知类

public class MyAdvice {

    //定义一个切入点规则

    @Pointcut("execution(* com.david.bean.IHelloWorld.*(..))")

    public void pc(){

    }

    @Before("MyAdvice.pc()")

    public void before() {

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

    }

    @After("MyAdvice.pc()")

    public void after() {

        System.out.println("后置通知，无论异常与否都会调用");

    }

    @AfterReturning("MyAdvice.pc()")

    public void afterRuning() {

        System.out.println("后置通知，出现异常不会调用");

    }

    @Around("MyAdvice.pc()")

    public void around(ProceedingJoinPoint pjp) throws Throwable {

        System.out.println("环绕前通知");

        Object proceed = pjp.proceed();//调用目标方法

        System.out.println("环绕后通知");

    }

}

巴特西

spring注解、aop（二）

最新文章

热门文章