使用注解配置Spring、Spring-Aop

使用注解配置Spring

导包

使用注解配置Spring需要导入 spring-aop-4.2.4.RELEASE.jar 包

导入约束

在主配置文件中导入新的命名空间，也就是导入约束

xmlns:context="http://www.springframework.org/schema/context" 

开启使用注解代替配置文件

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

在主配置文件applicationContext.xml中，全部代码如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns="http://www.springframework.org/schema/beans" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd ">

    <!-- 
        指定扫描com.jinxin.bean包下所有类的注解
        注意：扫描包时会扫描该包下所有的子孙包
    -->
    <context:component-scan base-package="com.jinxin.bean"></context:component-scan>

</beans>

开始使用注解

将对象注册到容器

在要交给容器管理的类上面使用 @Component("name") 注解，就可以代替<bean>标签

考虑到区分不同的代码层也可以分别使用如下三个标签来注册

@Service("name")    // service层
@Controller("name") // web层
@Repository("name") // Dao层 

 效果同@Component("name")一致

例：

将UserInfo交给容器管理

import org.springframework.stereotype.Component;

@Component("userinfo")
public class UserInfo {
    private String name;
    private Integer age;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

测试

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

public class NewTest {
    @Test
    public void test() {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserInfo ui = (UserInfo) ac.getBean("userinfo");
        System.out.println(ui);
    }
}

修改对象的作用范围

使用 @Scope(ScopeName="property") 代替<bean>标签里面的scope属性为对象设置作用范围

例：

将UserInfo修改为多例

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component("userinfo")
@Scope(scopeName="prototype")
public class UserInfo {
    private String name;
    private Integer age;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    
}

测试

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

public class NewTest {
    @Test
    public void test() {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserInfo ui = (UserInfo) ac.getBean("userinfo");
        UserInfo ui1 = (UserInfo) ac.getBean("userinfo");
        System.out.println(ui == ui1);
    }
}

值类型注入

值类型注入可以使用属性注入跟set方法注入(推荐)两种，其中set方法注入更加推荐

例：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component("userinfo")
@Scope(scopeName="prototype")
public class UserInfo {
    @Value("timo")    // 属性注入
    private String name;
    private Integer age;
    
    public String getName() {
        return name;
    }
    @Value("taylor")     // set方法注入(推荐)
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    
}

引用类型注入

引用类型注入分为两种，自动装配(@Autowired)跟手动装配(@Resource(name="girlfriend"))

例：

准备一个GirlFriend类作为UserInfo的引用类型属性

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;

@Repository("girlfriend")
public class GirlFriend {
    private String name;
    private Integer age;
    
    public String getName() {
        return name;
    }
    @Value("Scarlet")
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    @Value("18")
    public void setAge(Integer age) {
        this.age = age;
    }
}

在UserInfo中为其注入值

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component("userinfo")
@Scope(scopeName="prototype")
public class UserInfo {
    private String name;
    private Integer age;
    @Autowired      // 自动装配
    @Resource(name="girlfriend")    // 手动装配(指定girlfriend为装配对象)
    private GirlFriend girlFriend;
    
    public GirlFriend getGirlFriend() {
        return girlFriend;
    }
    
    public void setGirlFriend(GirlFriend girlFriend) {
        this.girlFriend = girlFriend;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return girlFriend.getName() + "-->" + girlFriend.getAge();
    }
}

测试

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

public class NewTest {
    @Test
    public void test() {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserInfo ui = (UserInfo) ac.getBean("userinfo");
        System.out.println(ui);
    }
}

初始化&销毁方法

使用注解 @PostConstruct 跟 @PreDestory 指定初始化方法跟销毁方法

例：

@PostConstruct
public void start(){
    System.out.println("我是初始化方法");
}

@PreDestory
public void destory(){
    System.out.println("我是方法");
}

名词学习

• 连接点：目标对象中，所有可以增强的方法
• 切入点：目标对象中，已经增强的方法
• 通知/增强：增强的代码
• 目标对象：被代理的对象
• 织入：将通知应用到切入点的过程
• 代理：将通知织入到目标对象，形成代理对象
• 切面：切入点+通知

Spring-aop

• 前置通知：目标方法运行之前执行
• 后置通知：目标方法之后运行，如果出现异常则不会调用
• 环绕通知：在目标方法运行之前和之后都会调用
• 异常拦截通知：如果出现异常就会调用
• 后置通知：目标方法运行之后调用，无论是否出现异常都会调用

首先准备一个类作为通知类

这个类主要存放的是前置通知后置通知等执行的方法

import org.aspectj.lang.ProceedingJoinPoint;
public class MyAdvice {
	// 前置通知
	public void before() {
		System.out.println("这是前置通知");
	}
	// 后置通知
	public void afterReturning() {
		System.out.println("这是后置通知 出现异常不调用");
	}
	// 环绕通知
	public Object around(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("这是环绕通知之前的部分");
		Object proeed = pjp.proceed();
		System.out.println("这是环绕通知之后的部分");
		return proeed;
	}
	// 异常拦截通知
	public void afterException() {
		System.out.println("异常拦截通知");
	}
	// 后置通知
	public void after() {
		System.out.println("后置通知  (无论是否出现异常都会调用)");
	}
}

准备一个类作为被通知的类

这个类是我们需要执行的类，在执行类中的方法的时候会调用前置通知，后置通知，环绕通知等一系列通知

public class UserService {
	public void save() {
		System.out.println("保存方法");
	}
}

在主配置文件中进行配置

虽然已经有了通知类和被通知类，但是还需要在配置文件中进行配置指定被通知类的前置通知，后置通知等要执行方法

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns="http://www.springframework.org/schema/beans" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">

	<!-- 
	    指定扫描com.jinxin.bean包下所有类的注解
        注意：扫描包时会扫描该包下所有的子孙包
    -->
	<context:component-scan base-package="com.jinxin.bean"></context:component-scan>

	<!-- 配置目标对象 -->
	<bean name="user" class="com.jinxin.bean.UserService"></bean>
	<!-- 配置通知对象 -->
	<bean name="myAdvice" class="com.jinxin.aop.MyAdvice"></bean>
	
	<aop:config>
		<!-- 配置切入点  
			public void com.jinxin.bean.UserService.save()
			void com.jinxin.bean.UserService.save()
			* com.jinxin.bean.UserService.*()
			
			* com.jinxin.bean.UserService.*(..)
			
			* com.jinxin.bean.*Service.*(..)
		-->
		<aop:pointcut expression="execution(* com.jinxin.bean.*Service.*(..))" id="pc"/>
		<aop:aspect ref="myAdvice">
			<!--指定名为before方法作为前置通知  -->
			<aop:before method="before" pointcut-ref="pc" />			
			<!--指定名为afterReturning方法作为后置通知  -->
			<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>
</beans>

 在配置切入点的时候有一个小插曲，原本要配置的形态是这样 public void com.jinxin.bean.UserService.save() ，最后却变成了这样 * com.jinxin.bean.*Service.*(..) ，下面对这些*号进行一一的解释

public void   --->   *

将public void用*代替表示了可以通知任意类型的方法

UserService  --->  *Service

将UserService用*Service代替，表示可以通知任意xxxService形式的类

save  --->  *

将save方法替换成了*表示可以通知该类中所有的方法

()  --->  (..)

将()替换成(..)表示可以接受任意参数的方法