学习 Spring (十六) AOP API

Spring入门篇 学习笔记

Spring AOP API 是 Spring 1.2 历史用法，现在仍然支持

这是 Spring AOP 基础，现在的用法也是基于历史的，只是更简便了

Pointcut

实现之一：NameMatchMethodPointcut

根据方法名字进行匹配

成员变量：mappedNames，匹配的方法名集合

1
2
3
4
5
6
7
<bean id="pointcutBean" class="org.springframework.aop.support.NameMatchMethodPointcut"> 
	<property name="mappedNames"> 
		<list> 
			<value>sa*</value> 
		</list> 
	</property> 
</bean>

Before advice

只是在进入方法之前被调用，不需要 MethodInvocation 对象

前置通知可以在连接点执行之前插入自定义行为，但不能改变返回值

1
2
3
4
5
6
7
8
9
10
public class MoocBeforeAdvice implements MethodBeforeAdvice {

	@Override
	public void before(Method method, Object[] args, Object target)
			throws Throwable {
		System.out.println("MoocBeforeAdvice : " + method.getName() + ", " +
				 target.getClass().getName());
	}

}

Throws advice

如果连接点抛出异常，throws advice 在连接点返回后被调用

如果 throws-advice 的方法抛出异常，那么它将覆盖原有异常

接口org.springframework.aop.ThrowsAdvice 不包含任何方法，仅仅是一个声明，实现类需要实现类似下面的方法：void afterThrowing([Method, args, target], ThrowableSubclass)

1
2
3
4
5
6
7
8
9
10
11
12
public class MoocThrowsAdvice implements ThrowsAdvice {
	
	public void afterThrowing(Exception ex) throws Throwable {
		System.out.println("MoocThrowsAdvice afterThrowing 1");
	}
	
	public void afterThrowing(Method method, Object[] args, Object target, Exception ex) throws Throwable {
		System.out.println("MoocThrowsAdvice afterThrowing 2 : " + method.getName() + ", " + 
				target.getClass().getName());
	}

}

After Returning advice

可以访问返回值(但不能进行修改)、被调用的方法、方法的参数和目标

如果抛出异常，将会抛出拦截器链，替代返回值

1
2
3
4
5
6
7
8
9
10
public class MoocAfterReturningAdvice implements AfterReturningAdvice {

	@Override
	public void afterReturning(Object returnValue, Method method,
			Object[] args, Object target) throws Throwable {
		System.out.println("MoocAfterReturningAdvice : " + method.getName() + ", " + 
			target.getClass().getName() + ", " + returnValue);
	}

}

Interception around advice

Spring 的切入点模型使得切入点可以独立与 advice 重用，以针对不同的 advice 可以使用相同的切入点

1
2
3
4
5
6
7
8
9
10
11
12
public class MoocMethodInterceptor implements MethodInterceptor {

	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		System.out.println("MoocMethodInterceptor 1 : " + invocation.getMethod().getName() + ", " + 
				invocation.getStaticPart().getClass().getName());
		 Object obj = invocation.proceed();
		 System.out.println("MoocMethodInterceptor 2 : " + obj);
		 return obj;
	}

}

Introduction advice

Spring 把引入通知作为一种特殊的拦截通知

仅使用于类，不能和任何切入点一起使用

需要同时实现 IntroductionAdvisor 和 IntroductionInterceptor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public interface Lockable {
	
	void lock();

	void unlock();

	boolean locked();

}

// 通常不是直接去实现 IntroductionInterceptor 接口，而是继承 DelegatingIntroductionInterceptor
public class LockMixin extends DelegatingIntroductionInterceptor implements Lockable {

	private boolean locked;

    public void lock() {
        this.locked = true;
    }

    public void unlock() {
        this.locked = false;
    }

    public boolean locked() {
        return this.locked;
    }

    public Object invoke(MethodInvocation invocation) throws Throwable {
        if (locked() && invocation.getMethod().getName().indexOf("set") == 0) {
            throw new RuntimeException();
        }
        return super.invoke(invocation);
    }

}

// 持有独立的 LockMixin 实例
public class LockMixinAdvisor extends DefaultIntroductionAdvisor {

	public LockMixinAdvisor() {
        super(new LockMixin(), Lockable.class);
    }
}

Advisor

Advisor 是仅包含一个切入点表达式关联的单个通知的方面

除了 introductions, advisor 可以用于任何通知

org.springframework.aop.support.DefaultPointcutAdvisor 是最常用的 advisor 类，它可以与 MethodInterceptor, BeforeAdvice 或者 ThrowsAdvice 一起使用

它可以混合在 Spring 同一个 AOP 代理的 advisor 和 advice

ProxyFactoryBean

创建 Spring AOP 代理的基本方法是使用 ProxyFactoryBean，这样可以完全控制切入点和通知以及它们的顺序

使用 ProxyFactoryBean 或者其他 IoC 相关类来创建 AOP 代理最重要的好处是通知和切入点也可以由 IoC 来管理

如果被代理类没有实现任何接口，使用 CGLIB 代理，否则使用 JDK 代理

通过设置 proxyTargetClass 为 true，可强制使用 CGLIB

如果目标类实现了一个(或者多个)接口，那么创建代理的类型将依赖 ProxyFactoryBean 的配置

如果 ProxyFactoryBean 的 proxyInterfaces 属性被设置为一个或者多个全限定接口名，基于 JDK 的代理将被创建

如果 ProxyFactoryBean 的 proxyInterfaces 属性没有被设置，但是目标类实现了一个(或者更多)接口，那么 ProxyFactoryBean 将自动检测到这个目标类已经实现了至少一个接口，创建一个基于 JDK 的代理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!--对应的是 ProxyFactoryBean，target 指向的才是目标类-->
	<bean id="bizLogicImpl" class="org.springframework.aop.framework.ProxyFactoryBean">
		<property name="target">
			<ref bean="bizLogicImplTarget"/>
		</property>
		<property name="interceptorNames">
			<list>
				<value>defaultAdvisor</value>
				<value>moocAfterReturningAdvice</value>
				<value>moocMethodInterceptor</value>
				<value>moocThrowsAdvice</value>
			</list>
		</property>
	</bean>

实例

使用 Pointcut

添加：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public interface BizLogic {
	
	String save();

}


public class BizLogicImpl implements BizLogic {
	
	public String save() {
		System.out.println("BizLogicImpl : BizLogicImpl save.");
		return "BizLogicImpl save.";
//		throw new RuntimeException();
	}

}

添加配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
<?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"
    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">
        
     <bean id="moocBeforeAdvice" class="com.karonda.aop.api.MoocBeforeAdvice"></bean>
     
     <bean id="moocAfterReturningAdvice" class="com.karonda.aop.api.MoocAfterReturningAdvice"></bean>
     
     <bean id="moocMethodInterceptor" class="com.karonda.aop.api.MoocMethodInterceptor"></bean>
     
     <bean id="moocThrowsAdvice" class="com.karonda.aop.api.MoocThrowsAdvice"></bean>
     

     <bean id="bizLogicImplTarget" class="com.karonda.aop.api.BizLogicImpl"></bean>

 	<bean id="pointcutBean" class="org.springframework.aop.support.NameMatchMethodPointcut">
 		<property name="mappedNames">
 			<list>
 				<value>sa*</value>
 			</list>
 		</property>
 	</bean>
	
 	<bean id="defaultAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
 		<property name="advice" ref="moocBeforeAdvice" />
 		<property name="pointcut" ref="pointcutBean" />
 	</bean>

	<!--对应的是 ProxyFactoryBean，target 指向的才是目标类-->
 	<bean id="bizLogicImpl" class="org.springframework.aop.framework.ProxyFactoryBean">
 		<property name="target">
 			<ref bean="bizLogicImplTarget"/>
 		</property>
 		<property name="interceptorNames">
 			<list>
 				<value>defaultAdvisor</value>
 				<value>moocAfterReturningAdvice</value>
 				<value>moocMethodInterceptor</value>
 				<value>moocThrowsAdvice</value>
 			</list>
 		</property>
 	</bean>

 </beans>

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RunWith(BlockJUnit4ClassRunner.class)
public class TestAOPAPI extends UnitTestBase {
	
	public TestAOPAPI() {
		super("classpath:spring-aop-api.xml");
	}
	
	@Test
	public void testSave() {
		BizLogic logic = (BizLogic)super.getBean("bizLogicImpl");
		logic.save();
	}

}

不使用 Pointcut

修改配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<?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"
    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">
        
     <bean id="moocBeforeAdvice" class="com.karonda.aop.api.MoocBeforeAdvice"></bean>
     
     <bean id="moocAfterReturningAdvice" class="com.karonda.aop.api.MoocAfterReturningAdvice"></bean>
     
     <bean id="moocMethodInterceptor" class="com.karonda.aop.api.MoocMethodInterceptor"></bean>
     
     <bean id="moocThrowsAdvice" class="com.karonda.aop.api.MoocThrowsAdvice"></bean>
     

     <bean id="bizLogicImplTarget" class="com.karonda.aop.api.BizLogicImpl"></bean>


 	<bean id="bizLogicImpl" class="org.springframework.aop.framework.ProxyFactoryBean">
 		<property name="proxyInterfaces">
 			<value>com.karonda.aop.api.BizLogic</value>
 		</property>
 		<property name="target">
 			<ref bean="bizLogicImplTarget"/>
 		</property>
 		<property name="interceptorNames">
 			<list>
 				<value>moocBeforeAdvice</value>
 				<value>moocAfterReturningAdvice</value>
 				<value>moocMethodInterceptor</value>
 				<value>moocThrowsAdvice</value>
 			</list>
 		</property>
 	</bean>

 </beans>

可以使用匿名内部 bean 来隐藏目标和代理之间的区别(推荐做法，可以避免直接使用 getBean 获取原始对象绕过代理而不会执行 advice)，上述配置修改：

  1. 移除： <bean id="moocThrowsAdvice" class="com.karonda.aop.api.MoocThrowsAdvice"></bean>
  2. <property name="target"> 修改为：<bean class="com.karonda.aop.api.BizLogicImpl"></bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<bean id="bizLogicImpl" class="org.springframework.aop.framework.ProxyFactoryBean">
	<property name="proxyInterfaces">
		<value>com.karonda.aop.api.BizLogic</value>
	</property>
	<property name="target">
	<bean class="com.karonda.aop.api.BizLogicImpl"></bean>
	</property>
	<property name="interceptorNames">
		<list>
			<value>moocBeforeAdvice</value>
			<value>moocAfterReturningAdvice</value>
			<value>moocMethodInterceptor</value>
			<value>moocThrowsAdvice</value>
		</list>
	</property>
</bean>

Proxying class

CGLIB 代理的工作原理是在运行时生成目标类的子类，Spring 配置这个生成的子类委托方法调用到原来的目标

子类是用 Decorator 模式，织入通知

CGLIB 的代理对用户是透明的，需要注意：

  • final 方法不能被通知，因为它们不能被覆盖
  • 不用把 CGLIB 添加到 classpath 中，在 Spring 3.2 之后 CGLIB 被重新包装并包含在 Spring 核心的JAR (即基于 CGLIB 的 AOP 就像 JDK 动态代理一样“开箱即用”)

global advisor

用 * 做通配，匹配所有拦截器加入通知链(实现了 MethodInterceptor 接口的)

示例：

moocMethodInterceptor 可以修改为 mooc*：

1
2
3
4
5
6
7
8
9
<property name="interceptorNames">
	<list>
		<value>moocBeforeAdvice</value>
		<value>moocAfterReturningAdvice</value>
		<!--<value>moocMethodInterceptor</value>-->
		<value>mooc*</value>
		<value>moocThrowsAdvice</value>
	</list>
</property>

简化的 proxy 定义

使用父子 bean 定义以及内部 bean 定义，可能会带来更清洁和更简洁的代理定义(抽象属性标记父 bean 定义为 abstract，这样它不能被实例化)

示例：

修改配置文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<?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"
    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">
        
     <bean id="moocBeforeAdvice" class="com.karonda.aop.api.MoocBeforeAdvice"></bean>
     
     <bean id="moocAfterReturningAdvice" class="com.karonda.aop.api.MoocAfterReturningAdvice"></bean>
     
     <bean id="moocMethodInterceptor" class="com.karonda.aop.api.MoocMethodInterceptor"></bean>
     
     <bean id="moocThrowsAdvice" class="com.karonda.aop.api.MoocThrowsAdvice"></bean>


	<bean id="baseProxyBean" class="org.springframework.aop.framework.ProxyFactoryBean"
		  lazy-init="true" abstract="true"></bean>

	<bean id="bizLogicImpl"  parent="baseProxyBean">
		<property name="target">
			<bean class="com.karonda.aop.api.BizLogicImpl"></bean>
		</property>
		<property name="proxyInterfaces">
			<value>com.karonda.aop.api.BizLogic</value>
		</property>
		<property name="interceptorNames">
			<list>
				<value>moocBeforeAdvice</value>
				<value>moocAfterReturningAdvice</value>
				<value>moocMethodInterceptor</value>
				<value>moocThrowsAdvice</value>
			</list>
		</property>
	</bean>

 </beans>

使用 ProxyFactory

使用 Spring AOP 而不必依赖于 Spring IoC：

1
2
3
4
ProxyFactory factory = new ProxyFactory(myBusinessInterfaceImpl);
factory.addAdvice(myMethodInterceptor);
factory.addAdvisor(myAdvisor);
MyBusinessInterface tb = (MyBusinessInterface)factory.getProxy();

大多数情况下最佳实践是使用 IoC 容器创建 AOP 代理

虽然可以硬编码方式实现，但是 Spring 推荐使用配置或注解方式实现

使用 “auto-proxy”

Spring 也允许使用”自动代理“的 bean 定义，它可以自动代理选定的 bean，这是建立在 Spring 的 “bean post processor” 功能基础上的(在加载 bean 的时候就可以修改)

1
2
3
4
5
6
7
8
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
    <property name="beanNames" value="jdk*,onlyJdk"/>
	<property name="interceptorNames">
	    <list>
		    <value>myInterceptor</value>
		</list>
	</property>
</bean>

使用 DefaultAdvisorAutoPorxyCreator，当前 IoC 容器中自动应用，不用显示声明引用 advisor 的 bean 定义

1
2
3
4
5
6
7
8
9
10
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoPorxyCreator"/>

<bean class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
    <property name="transactionInterceptor" ref="transactionInterceptor"/>
</bean>

<bean id="customAdvisor" class="com.mycompany.MyAdvisor"/>
<bean id="bussinessObject1" class="com.mycompany.BusinessObject1">
    <!-- 可以省略 Properties 定义-->
</bean>

源码：learning-spring

展开全文 >>

学习 Spring (十五) Advisor

Spring入门篇 学习笔记

advisor 就像一个小的自包含的方面，只有一个 advice

切面自身通过一个 bean 表示，并且必须实现某个 advice 接口，同时 advisor 也可以很好的利用 AspectJ 的切入点表达式

Spring 通过配置文件中 aop:advisor 元素支持 advisor，实际使用中，大多数情况下它会和 transactional advice 配合使用

为了定义一个 advisor 的优先级以便让 advice 可以有序，可以使用 order 属性来定义 advisor 的顺序

示例

添加切面：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class ConcurrentOperationExecutor implements Ordered {

	private static final int DEFAULT_MAX_RETRIES = 2;

	private int maxRetries = DEFAULT_MAX_RETRIES;
	
	private int order = 1;

	public void setMaxRetries(int maxRetries) {
		this.maxRetries = maxRetries;
	}

	public int getOrder() {
		return this.order;
	}

	public void setOrder(int order) {
		this.order = order;
	}

	public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable {
		int numAttempts = 0;
		PessimisticLockingFailureException lockFailureException;
		do {
			numAttempts++;
			System.out.println("Try times : " + numAttempts);
			try {
				return pjp.proceed();
			} catch (PessimisticLockingFailureException ex) {
				lockFailureException = ex;
			}
		} while (numAttempts <= this.maxRetries);
		System.out.println("Try error : " + numAttempts);
		throw lockFailureException;
	}
}

添加类：

1
2
3
4
5
6
7
8
9
10
11
12
@Service
public class InvokeService {
	
	public void invoke() {
		System.out.println("InvokeService ......");
	}
	
	public void invokeException() {
		throw new PessimisticLockingFailureException("");
	}

}

添加配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<?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"
    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">

	<context:component-scan base-package="com.karonda.aop.schema"></context:component-scan>

	<aop:config>
		<aop:aspect id="concurrentOperationRetry" ref="concurrentOperationExecutor">
			<aop:pointcut id="idempotentOperation"
				expression="execution(* com.karonda.aop.schema.advisors.service.*.*(..)) " />
			<aop:around pointcut-ref="idempotentOperation" method="doConcurrentOperation" />
		</aop:aspect>
	</aop:config>
	
	<bean id="concurrentOperationExecutor" class="com.karonda.aop.schema.advisors.ConcurrentOperationExecutor">
		<property name="maxRetries" value="3" />
		<property name="order" value="100" />
	</bean>

 </beans>

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@RunWith(BlockJUnit4ClassRunner.class)
public class TestAOPSchemaAdvisors extends UnitTestBase {
	
	public TestAOPSchemaAdvisors() {
		super("classpath:spring-aop-schema-advisors.xml");
	}
	
	@Test
	public void testSave() {
		InvokeService service = super.getBean("invokeService");
		service.invoke();
		
		System.out.println();
		service.invokeException();
 	}

}

源码：learning-spring

展开全文 >>

学习 Spring (十四) Introduction

Spring入门篇 学习笔记

Introduction 允许一个切面声明一个实现指定接口的通知对象，并且提供了一个接口实现类来代表这些对象

由 aop:aspect 中的 aop:declare-parents 元素声明该元素用于声明所匹配的类型拥有一个新的 parents

示例

新增接口：

1
2
3
4
5
public interface Fit {
	
	void filter();

}

添加实现：

1
2
3
4
5
6
7
8
public class FitImpl implements Fit {

	@Override
	public void filter() {
		System.out.println("FitImpl filter.");
	}

}

修改配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

	<bean id="moocAspect" class="com.karonda.aop.schema.advice.MoocAspect"></bean>

	<bean id="aspectBiz" class="com.karonda.aop.schema.advice.biz.AspectBiz"></bean>

	<aop:config>
		<aop:aspect id="moocAspectAOP" ref="moocAspect">
			<!--Introduction-->
			<aop:declare-parents types-matching="com.karonda.aop.schema.advice.biz.*(+)"
								 implement-interface="com.karonda.aop.schema.advice.Fit"
								 default-impl="com.karonda.aop.schema.advice.FitImpl"/>

		</aop:aspect>
	</aop:config>

 </beans>

添加测试：

1
2
3
4
5
@Test
public void testFit(){
    Fit fit = (Fit)super.getBean("aspectBiz");
    fit.filter();
}

schema-defined (基于配置文件) aspects 只支持 singleton model

源码：learning-spring

展开全文 >>

学习 Spring (十三) AOP 配置

Spring入门篇 学习笔记

Spring 所有的切面和通知器都必须放在一个 aop:config 内(可以配置包含多个 aop:config 元素)，每一个 aop:config 可以包含 pointcut, advisor 和 aspect 元素(它们必须按照这个顺序进行声明)

aop:config 风格的配置大量使用了 Spring 的自动代理机制

配置 Aspect

新建切面类：

1
2
3
public class MoocAspect {
	
}

添加配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

	<bean id="moocAspect" class="com.karonda.aop.schema.advice.MoocAspect"></bean>
	
	<aop:config>
		<aop:aspect id="moocAspectAOP" ref="moocAspect">

		</aop:aspect>
	</aop:config>

 </beans>

配置 Pointcut

pointcut 类型说明详见：pointcut expressions

新建类：

1
2
3
public class AspectBiz {

}

修改配置文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

	<bean id="moocAspect" class="com.karonda.aop.schema.advice.MoocAspect"></bean>

	<bean id="aspectBiz" class="com.karonda.aop.schema.advice.biz.AspectBiz"></bean>
	
	<aop:config>
		<aop:aspect id="moocAspectAOP" ref="moocAspect">
			<aop:pointcut id="moocPointcut" expression="execution(* com.karonda.aop.schema.advice.biz.*Biz.*(..))"/>

		</aop:aspect>
	</aop:config>

 </beans>

Advice

添加依赖包 aspectjweaver：

1
2
3
4
5
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.13</version>
</dependency>

修改 MoocAspect：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class MoocAspect {

	public void before(){
	    System.out.println("MoocAspect before.");
    }

    public void afterReturning(){
		System.out.println("MoocAspect afterReturning.");
	}

	public void afterThrowing(){
		System.out.println("MoocAspect afterThrowing.");
	}

	public void after(){
		System.out.println("MoocAspect after.");
	}

	// 环绕通知方法的第一个参数必须是 ProceedingJoinPoint 类型
	public Object around(ProceedingJoinPoint pjp){
		Object obj = null;
		try{
			System.out.println("MoocAspect around 1.");
			obj = pjp.proceed();
			System.out.println("MoocAspect around 2.");
		}catch (Throwable e){
			e.printStackTrace();
		}

		return obj;
	}

	public Object aroundInit(ProceedingJoinPoint pjp, String bizName, int times){
		System.out.println(bizName + " " + times);
		Object obj = null;
		try{
			System.out.println("MoocAspect aroundInit 1.");
			obj = pjp.proceed();
			System.out.println("MoocAspect aroundInit 2.");
		}catch (Throwable e){
			e.printStackTrace();
		}

		return obj;
	}
}

修改 AspectBiz：

1
2
3
4
5
6
7
8
9
10
11
12
public class AspectBiz {
	
	public void biz() {
		System.out.println("AspectBiz biz.");
//		throw new RuntimeException();
	}

	public void init(String bizName, int times){
		System.out.println("AspectBiz init: " + bizName + " " + times);
	}

}

修改配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<?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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

	<bean id="moocAspect" class="com.karonda.aop.schema.advice.MoocAspect"></bean>

	<bean id="aspectBiz" class="com.karonda.aop.schema.advice.biz.AspectBiz"></bean>

	<aop:config>
		<aop:aspect id="moocAspectAOP" ref="moocAspect">
			<aop:pointcut expression="execution(* com.karonda.aop.schema.advice.biz.*Biz.*(..))" id="moocPiontcut"/>
			<!--前置通知-->
			<aop:before method="before" pointcut-ref="moocPiontcut"/>
			<!--返回后通知-->
			<aop:after-returning method="afterReturning" pointcut-ref="moocPiontcut"/>
			<!--抛出异常通知-->
			<aop:after-throwing method="afterThrowing" pointcut-ref="moocPiontcut" />
			<!--后通知-->
			<aop:after method="after" pointcut-ref="moocPiontcut"/>
			<!--环绕通知-->
			<aop:around method="around" pointcut-ref="moocPiontcut"/>
			<!--带参数-->
			<aop:around method="aroundInit" pointcut="execution(* com.karonda.aop.schema.advice.biz.AspectBiz.init(String, int))
				and args(bizName, times)"/>

		</aop:aspect>
	</aop:config>

 </beans>

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@RunWith(BlockJUnit4ClassRunner.class)
public class TestAOPSchemaAdvice extends UnitTestBase {
    public TestAOPSchemaAdvice(){
        super("classpath:spring-aop-schema-advice.xml");
    }

    @Test
    public void testBiz(){
        AspectBiz biz = super.getBean("aspectBiz");
        biz.biz();
    }

    @Test
    public void testInit(){
        AspectBiz biz = super.getBean("aspectBiz");
        biz.init("moocService", 3);
    }
}

源码：learning-spring

展开全文 >>

学习 Spring (十二) AOP 基本概念及特点

Spring入门篇 学习笔记

AOP: Aspect Oriented Programming, 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术

主要功能是：日志记录、性能统计、安全控制、事务处理、异常处理等

AOP 实现方式

  1. 预编译：AspectJ
  2. 运行期动态代理(JDK 动态代理, CGLib 动态代理)：SpringAOP, JbossAOP

AOP 相关概念

  • 切面 (Aspect)：一个关注点的模块化，这个关注点可能会横切多个对象
  • 连接点 (Joinpoint)：程序执行过程中某个特定的点
  • 通知 (Advice)：在切面的某个特定的连接点上执行的动作
  • 切入点 (Pointcut)：匹配连接点的断言，在 AOP 中通知和一个切入点表达式关联
  • 引入 (Introduction)：在不修改类代码的前提下，为类添加新的方法和属性
  • 目标对象 (Target Object)：被一个或者多个切面所通知的对象
  • AOP 代理 (AOP Proxy)：AOP 框架创建的对象，用来实现切面契约(aspect contract)(包括通知方法执行等功能)
  • 织入 (Weaving)：把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象，分为：编译时织入、类加载时织入、执行时织入

Advice 的类型

  1. 前置通知 (Before advice)：在某连接点之前执行的通知，但不能阻止连接点前的执行(除非它抛出一个异常)
  2. 返回后通知 (After returning advice)：在某连接点正常完成后执行的通知
  3. 抛出异常通知 (After throwing advice)：在方法抛出异常退出时执行的通知
  4. 后通知 (After (finally) advice)：当某连接点退出的时候执行的通知(不论是正常返回还是异常退出)
  5. 环绕通知 (Around advice)：包围一个连接点的通知

Spring 框架中 AOP 的用途

  • 提供了声明式的企业服务，特别是 EJB 的替代服务的声明
  • 允许用户定制自己的切面，以完成 OOP 与 AOP 的互补使用

Spring 的 AOP 实现方式：

  • 纯 java 实现，无需特殊大的编译过程，不需要控制类加载器层次
  • 目前只支持方法执行连接点(通知 Spring Bean 的方法执行)
  • 不是为了提供最完整的 AOP 实现，而是侧重于提供一种 AOP 实现和 Spring IoC 容器之间的整合，用于帮助解决企业应用中的常见问题
  • Spring AOP 不会与 AspectJ 竞争，不会提供综合全面的 AOP 解决方案

有接口和无接口的 Spring AOP 实现区别

  • Spring AOP 默认使用标准的 Jave SE 动态代理作为 AOP 代理，这使得任何接口(或者接口集)都可以被代理
  • Spring AOP 中也可以使用 CGLIB 代理(如果一个业务对象并没有实现一个接口)

源码：learning-spring

展开全文 >>

学习 Spring (十一) 注解之 Spring 对 JSR 支持

Spring入门篇 学习笔记

@Resource

Spring 还支持使用 JSR-250 中的 @Resource 注解的变量或 setter 方法

@Resource 有一个 name 属性，并且默认 Spring 解释该值作为被注入 bean 的名称

1
2
3
4
5
6
7
8
public class SimpleMovieLister{
    private MovieFinder movieFinder;
	
	@Resource(name="myMovieFinder")
	public void setMovieFinder(MovieFinder movieFinder){
	    this.movieFinder = movieFinder;
	}
}

如果没有显式指定 @Resource 的 name，默认名称 是从属性名或 setter 方法得出

注解提供的名字被解析为一个 bean 的名称，这是由 ApplicationContext 中的 CommonAnnotationBeanPostProcessor 发现并处理的

CommonAnnotationBeanPostProcessor 不仅能识别 JSR-250 中的生命周期注解 @Resource，在Spring 2.5 中引入支持初始化回调和销毁回调，前提是 CommonAnnotationBeanPostProcessor 是在 Spring 的 ApplicationContext 中注册的

1
2
3
4
5
6
7
8
9
10
11
12
13
public class CachingMovieLister{
    
	@PostConstruct
	public void popularMovieCache(){
	
	}
	
	@PreDestory
	public void clearMovieCache(){
	
	}

}

示例

添加类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@Repository
public class JsrDAO {
	
	public void save() {
		System.out.println("JsrDAO invoked.");
	}
	
}

@Service
public class JsrServie {
	
	@Resource
	private JsrDAO jsrDAO;
	
//	@Resource
	public void setJsrDAO(JsrDAO jsrDAO) {
		this.jsrDAO = jsrDAO;
	}

	@PostConstruct
	public void init() {
		System.out.println("JsrServie init.");
	}

	@PreDestroy
	public void destroy() {
		System.out.println("JsrServie destroy.");
	}

	public void save() {
		jsrDAO.save();
	}
	
}

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RunWith(BlockJUnit4ClassRunner.class)
public class TestJsr extends UnitTestBase {
	
	public TestJsr() {
		super("classpath*:spring-beanannotation.xml");
	}
	
	@Test
	public void testSave() {
		JsrServie service = getBean("jsrServie");
		service.save();
	}
	
}

JSR330 标准注解

从 Spring 3.0 开始支持 JSR330 标准注解(依赖注入注解)，其扫描方式与 Spring 注解一致

使用 JSR330 需要依赖 javax.inject 包

@Inject

@Inject 等效于 @Autowired，可以使用于类、属性、方法、构造器

@Named

  • 如果想使用特定名称 进行依赖注入，使用 @Named
  • @Named 与 @Component 是等效的

示例

添加 Maven 引用：

1
2
3
4
5
<dependency>
  <groupId>javax.inject</groupId>
  <artifactId>javax.inject</artifactId>
  <version>1</version>
</dependency>

修改 JsrServie 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//@Service
@Named
public class JsrServie {
	
//	@Resource
//	@Inject
	private JsrDAO jsrDAO;
	
//	@Resource
	@Inject
	public void setJsrDAO(@Named("jsrDAO") JsrDAO jsrDAO) {
		this.jsrDAO = jsrDAO;
	}

	@PostConstruct
	public void init() {
		System.out.println("JsrServie init.");
	}

	@PreDestroy
	public void destroy() {
		System.out.println("JsrServie destroy.");
	}

	public void save() {
		jsrDAO.save();
	}
	
}

源码：learning-spring

展开全文 >>

学习 Spring (十) 注解之 @Bean, @ImportResource, @Value, 基于泛型的自动装配

Spring入门篇 学习笔记

@Bean

@Bean 标识一个用于配置和初始化一个由 Spring IoC 容器管理的新对象的方法，类似于 XML 配置文件的

可以在 Spring 的 @Configuration 注解的类中使用 @Bean 注解任何方法，在方法里面创建对象返回

1
2
3
4
5
6
7
@Configuration
public class AppConfig{
    @Bean
	public MyService myService(){
	    return new MyServiceImpl();
	}
}

示例

新建类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public interface Store<T> {

}


public class StringStore implements Store<String> {
	
	public void init() {
		System.out.println("This is init.");
	}
	
	public void destroy() {
		System.out.println("This is destroy.");
	}
	
}

@Configuration
public class StoreConfig {

	@Bean(initMethod = "init", destroyMethod = "destroy")// 如果没有指定 name，那么name 为方法的名称
	public StringStore stringStore() {
		return new StringStore();
	}

}

添加测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RunWith(BlockJUnit4ClassRunner.class)
public class TestJavabased extends UnitTestBase {
	
	public TestJavabased() {
		super("classpath*:spring-beanannotation.xml");
	}
	
	@Test
	public void test() {
		Store store = super.getBean("stringStore");
		System.out.println(store.getClass().getName());
	}
	
}

@Bean 默认是单例的，如果要改变作用域范围，可以再添加 @Scope 注解

@ImportResource

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<beans>
        
    <context:annotation-config/>
    <!--加载资源文件-->
    <context:property-placeholder location="classpath:/com/acme/jdbc.properties"/>

    <bean class="com.acme.AppConfig"/>

    <!--引用资源文件中的配置内容-->
    <bean class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="url" value="${jdbc.username}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
        
 </beans>

使用 @ImportResource 可以代替上面 XML 配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Configuration
@ImportResource("classpath:/com/acme/properties-config.xml")
public class AppConfig{
    @Value("${jdbc.url")
	private String url;
	
	@Value("${jdbc.username}")
	private String username;
	
	@Value("${jdbc.password}")
	private String password;
	
	@Bean
	public DataSource dataSource(){
	    return new DriverManagerDataSource(url, username, password);
	}
}

示例：

添加类：

1
2
3
4
5
6
7
8
9
public class MyDriverManager {
	
	public MyDriverManager(String url, String userName, String password) {
		System.out.println("url : " + url);
		System.out.println("userName: " + userName);
		System.out.println("password: " + password);
	}

}

添加配置文件 config.properties：

1
2
3
jdbc.username=root
jdbc.password=root
jdbc.url=127.0.0.1

添加配置文件 config.xml：

1
2
3
4
5
6
7
8
9
10
11
12
<?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.xsd" >
        
    <context:property-placeholder location="classpath:/config.properties"/>
    
</beans>

修改类 StoreConfig：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Configuration
@ImportResource("classpath:config.xml")
public class StoreConfig {

	@Value("${jdbc.url}")
	private String url;

	@Value("${jdbc.username}")
	private String username;

	@Value("${jdbc.password}")
	private String password;

	@Bean
	public MyDriverManager myDriverManager(){
		return new MyDriverManager(url, username, password);
	}


//	@Bean(initMethod = "init", destroyMethod = "destroy")// 如果没有指定 name，那么name 为 方法的名称
//	public StringStore stringStore() {
//		return new StringStore();
//	}

}

添加测试：

1
2
3
4
5
@Test
public void testMyDriverManager() {
	MyDriverManager manager = super.getBean("myDriverManager");
	System.out.println(manager.getClass().getName());
}

基于泛型的自动装配

示例

新建类：

1
2
3
public class IntegerStore implements Store<Integer> {

}

修改类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@Configuration
@ImportResource("classpath:config.xml")
public class StoreConfig {

	@Autowired
	@Qualifier(value="stringStore")
	private Store<String> s1;

	@Autowired
	@Qualifier(value="integerStore")
	private Store<Integer> s2;


	@Bean
	public StringStore stringStore() {
		return new StringStore();
	}
	@Bean
	public IntegerStore integerStore() {
		return new IntegerStore();
	}

	@Bean
	public StringStore stringStoreTest(){
		System.out.println("s1: " + s1.getClass().getName());
		System.out.println("s2: " + s2.getClass().getName());
		return new StringStore();
	}
}

添加测试：

1
2
3
4
@Test
public void testG() {
	Store store = super.getBean("stringStoreTest");
}

源码：learning-spring

展开全文 >>

学习 Spring (九) 注解之 @Required, @Autowired, @Qualifier

Spring入门篇 学习笔记

@Required

@Required 注解适用于 bean 属性的 setter 方法

这个注解仅仅表示，受影响的 bean 属性必须在配置时被填充，通过在 bean 定义或通过自动装配一个明确的属性值：

1
2
3
4
5
6
7
8
public class SimpleMovieLister{
    private MovieFinder movieFinder;
	
	@Required
	public void SetMovieFinder(MovieFinder movieFinder){
	    this.movieFinder = movieFinder;
	}
}

@Required 使用比较少，一般使用 @Autowired

@Autowired: setter, 构造器, 成员变量自动注入

可以将 @Autowired 理解为“传统”的 setter 方法：

1
2
3
4
5
6
7
8
public class SimpleMovieLister{
    private MovieFinder movieFinder;
	
	@Autowired
	public void SetMovieFinder(MovieFinder movieFinder){
	    this.movieFinder = movieFinder;
	}
}

可用于构造器或成员变量：

1
2
3
4
5
6
7
8
9
10
11
@Autowired
private MovieCatalog movieCatalog;


private CustomerPreferenceDao customerPreferenceDao;

@Autowired
public MovieRecommender(CustomerPreferenceDao customerPreferenceDao){
    this.customerPreferenceDao = customerPreferenceDao;
}

默认情况下，如果因找不到合适的 bean 将会导致 autowiring 失败抛出异常，可以通过下面的方式避免：

1
2
3
4
5
6
7
8
9
public class SimpleMovieLister{
    private MovieFinder movieFinder;
	
	@Autowired(required=false)
	public void SetMovieFinder(MovieFinder movieFinder){
	    this.movieFinder = movieFinder;
	}
}

  • 每个类只能有一个构造器被标记为 required=true
  • @Autowired 的必要属性，建议使用 @Required 注解

示例

添加类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public interface InjectionDAO {
	
	void save(String arg);

}

@Repository
public class InjectionDAOImpl implements InjectionDAO {
	
	public void save(String arg) {
		//模拟数据库保存操作
		System.out.println("保存数据：" + arg);
	}

}

public interface InjectionService {
	
	void save(String arg);
	
}

@Service
public class InjectionServiceImpl implements InjectionService {

	// @Autowired
	private InjectionDAO injectionDAO;

	// @Autowired
	public void setInjectionDAO(InjectionDAO injectionDAO) {
		this.injectionDAO = injectionDAO;
	}

	@Autowired
	public InjectionServiceImpl(InjectionDAO injectionDAO) {
		this.injectionDAO = injectionDAO;
	}


	public void save(String arg) {
		//模拟业务操作
		System.out.println("Service(Property)接收参数：" + arg);
		arg = arg + ":" + this.hashCode();
		injectionDAO.save(arg);
	}
	
}

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@RunWith(BlockJUnit4ClassRunner.class)
public class TestInjection extends UnitTestBase {

    public TestInjection(){
        super("classpath:spring-beanannotation.xml");
    }

    @Test
    public void testAutowired(){
        InjectionService service = super.getBean("injectionServiceImpl");

        service.save("This is autowired.");
    }

}

@Autowired: 数组, Map 自动注入

可以使用 @Autowired 注解那些众所周知的解析依赖性接口，比如：BeanFactory, ApplicationContext, Environment, ResourceLoader, ApplicationEventPublisher, MessageSource

1
2
3
4
5
6
7
8
9
public class MovieRecommender{
    
	@Autowired
	private ApplicationContext context;
	
	public MovieRecommender(){
	}
}

可以通过添加注解给需要该类型的数组的字段或方法，以提供 ApplicationContext 中的所有特定类型的 bean

1
2
3
4
5
6
private Set<MovieCatalog> movieCatalog;

@Autowired
public void setMovieCatalogs(Set<MovieCatalog> movieCatalogs){
    this.movieCatalogs = movieCatalogs;
}

可以用于装配 key 为 String 的 Map

1
2
3
4
5
6
private Map<String, MovieCatalog> movieCatalogs;

@Autowired
public void setMovieCatalogs(Map<String, MovieCatalog> movieCatalogs){
    this.movieCatalogs = movieCatalogs;
}

如果希望数组有序，可以让 bean 实现 org.springframework.core.Ordered 接口或使用 @Order注解

@Autowired 是由 BeanPostProcessor 处理的，所以不能在自己的 BeanPostProcessor 或 BeanFactoryPostProcessor 类型应用这些注解，这些类型必须通过 XML 或者 @Bean 注解加载

示例

新建类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public interface BeanInterface {

}

@Order(value = 2)
@Component
public class BeanImplOne implements BeanInterface {

}

@Order(value = 1)
@Component
public class BeanImplTwo implements BeanInterface {

}

@Component
public class BeanInvoker {
	
	@Autowired
	private List<BeanInterface> list;
	
	@Autowired
	private Map<String, BeanInterface> map;
	
	public void say() {
		if (null != list && 0 != list.size()) {
			System.out.println("list...");
			for (BeanInterface bean : list) {
				System.out.println(bean.getClass().getName());
			}
		} else {
			System.out.println("List<BeanInterface> list is null !!!!!!!!!!");
		}
		
		System.out.println();
		
		if (null != map && 0 != map.size()) {
			System.out.println("map...");
			for (Map.Entry<String, BeanInterface> entry : map.entrySet()) {
				System.out.println(entry.getKey() + "      " + entry.getValue().getClass().getName());
			}
		} else {
			System.out.println("Map<String, BeanInterface> map is null !!!!!!!!!!");
		}

	}

}

在 TestInjection 中添加测试方法：

1
2
3
4
5
@Test
public void testMultiBean(){
	BeanInvoker invoker = super.getBean("beanInvoker");
	invoker.say();
}

@Qualifier

按类型自动装配可能多个 bean 实例的情况，可以使用 @Qualifier 注解缩小范围(或指定唯一)，也可以用于指定单独的构造器参数或方法参数

可用于注解集合类型变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class MovieRecommender{

    @Autowired
	@Qualifier("main")
	private MovieCatalog movieCatalog;
}


public class MovieRecommender{
    private MovieCatalog movieCatalog;
	private CustomerPreferenceDao customerPreferenceDao;
	
	@Autowired
	public void prepare(@Qualifier("main")MovieCatalog movieCatalog
	    , CustomerPreferenceDao customerPreferenceDao){
		this.movieCatalog = movieCatalog;
		this.customerPreferenceDao = customerPreferenceDao;
	}
}

在 XML 文件中实现 Qualifier：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?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.xsd" >
        
        <context:annotation-config />

        <bean class="example.SimpleMovieCatalog">
            <qualifier value="main"/>
        </bean>

        <bean class="example.SimpleMovieCatalog">
            <qualifier value="action"/>
        </bean>

        <bean id="movieRecommender" class="example.MovieRecommender" />
        
 </beans>

如果通过名字进行注解注入，主要使用的不是 @Autowired (即使在技术上能够通过 @Qualifier 指定 bean 的名字)，替代方式是使用 JSR-250 @Resource 注解，它是通过其独特的名称定义来识别特定的目标(这是一个与所声明的类型无关的匹配过程)

因语义差异，集合或 Map 类型的 bean 无法通过 @Autowired 来注入时，因为没有类型匹配到这样的 bean，为这些 bean 使用 @Resource 注解，通过唯一名称引用集合或 Map 的 bean

@Autowired 适用于 fields, constructors, multi-argument methods 这些允许在参数级别使用 @Qualifier 注解缩小范围的情况

@Resource 适用于成员变量、只有一个参数的 setter 方法，所以在目标时构造器或一个多参数方法时，最好的方式时使用 @Qualifier

可以定义自己的 qualifier 注解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Genre{
    String value();
}

public class MovieRecommender{
    @Autowired
	@Genre("Action")
	private MovieCatalog actionCatalog;
	private MovieCatalog comedyCatalog;
	
	@Autowired
	public void setComedyCatalog(@Genre("Comedy") MovieCatalog comedyCatalog){
	    this.comedyCatalog = comedyCatalog;
	}

}

示例

修改 BeanInvoker：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@Component
public class BeanInvoker {
	
	@Autowired
	private List<BeanInterface> list;
	
	@Autowired
	private Map<String, BeanInterface> map;

	@Autowired
	@Qualifier("beanImplTwo")
	private BeanInterface beanInterface;
	
	public void say() {
		if (null != list && 0 != list.size()) {
			System.out.println("list...");
			for (BeanInterface bean : list) {
				System.out.println(bean.getClass().getName());
			}
		} else {
			System.out.println("List<BeanInterface> list is null !!!!!!!!!!");
		}
		
		System.out.println();
		
		if (null != map && 0 != map.size()) {
			System.out.println("map...");
			for (Map.Entry<String, BeanInterface> entry : map.entrySet()) {
				System.out.println(entry.getKey() + "      " + entry.getValue().getClass().getName());
			}
		} else {
			System.out.println("Map<String, BeanInterface> map is null !!!!!!!!!!");
		}

		System.out.println();

		if (null != beanInterface) {
			System.out.println(beanInterface.getClass().getName());
		} else {
			System.out.println("beanInterface is null...");
		}

	}

}

源码：learning-spring

展开全文 >>

学习 Spring (八) 注解之 Bean 的定义及作用域

Spring入门篇 学习笔记

Classpath 扫描与组件管理

从 Spring 3.0 开始，Spring JavaConfig 项目提供了很多特性，包括使用 java 而不是 XML 定义 bean，比如 @Configuration, @Bean, @Import, @DependsOn

@Component 是一个通用注解，可用于任何 bean；@Repository, @Service, @Controller 是更具有针对性的注解：

  • @Repository 通常用于注解 DAO 类，即持久层
  • @Service 通常用于注解 Service 类，即服务层
  • @Controller 通常用于 Controller 类，即控制层 (MVC)

元注解 (Meta-annotations)

许多 Spring 提供的注解可以作为自己的代码，即“元数据注解“，元注解是一个简单的注解，可以应用到另一个注解(即注解的注解)

1
2
3
4
5
6
7
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component // 定义 @Service 注解时继承了 @Component 的所有特性 
public @interface Service{
    // ...
}

除了 value(), 元注解还可以有其他的属性，允许定制：

1
2
3
4
5
6
7
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Scope("session")
public @interface SessionScope{
    ScopedProxyMode proxyMode() default ScopedProxyMode.DEFAULT
}

类的自动检测与 Bean 的注册

Spring 可以自动检测类并注册 Bean 到 ApplicationContext 中

为了能够检测这些类并注册相应的 Bean，需要下面内容：

1
2
3
4
5
6
7
8
9
10
11
12
<?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.xsd">
        
        <context:component-scan base-package="org.example"/>
	
 </beans>

context:component-scan 包含 context:annotation-config, 通常在使用前者后，不再使用后者

使用过滤器进行自定义扫描

默认情况下，类被自动发现并注册 bean 的条件是：使用 @Component, @Repository, @Service, @Controller 注解或者使用 @Component 的自定义注解

可以通过过滤器修改上面的行为，如：下面例子的 XML 配置忽略所有的 @Repository 注解并用 Stub 代替：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?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.xsd">
        
        <context:component-scan base-package="org.example">
            <context:include-filter type="regex" expression=".*Stub.*Repository"/>
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
        </context:component-scan>
	
 </beans>

还可使用 use-default-filters= “false” 禁用自动发现与注册

定义 Bean

扫描过程中组件被自动检测，Bean 名称是由 BeanNameGenerator 生成的(@Component, @Repository, @Service, @Controller 都会有个 name 属性用于显示设置 Bean Name)：

1
2
3
4
5
6
7
8
9
@Service("myMovieLister")
public class SimpleMovieLister{
		// ...
}

@Repository // 没有设置 name 将使用默认 name(类名首字母小写)
public class MovieFinderImpl implements MovieFinder{
    // ...
}

可以自定义 bean 命名策略：实现 BeanNameGenerator 接口，并一定要包含一个无参数构造函数

1
2
3
4
5
6
7
8
9
10
11
<?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.xsd">
        
        <context:component-scan base-package="org.example"
                                name-generator="org.example.MyNameGenerrator"/>
	
 </beans>

作用域

通常情况下自动查找的 Spring 组建，其 scope 是 singleton，Spring 2.5 提供了一个 标识 scope 的注解 @Scope

1
2
3
4
5
@Scope("prototype")
@Repository
public class MovieFinderImpl implements MovieFinder{
    // ...
}

也可以自定义 scope 策略，实现 ScopeMetadataResolver 接口并提供一个无参构造函数

1
2
3
4
5
6
7
8
9
10
<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.xsd">
        
        <context:component-scan base-package="org.example"
                                scope-resolver="org.example.MyScopeResolver"/>
	
 </beans>

代理方式

可以使用 scoped-proxy 属性指定代理，有三个值可选：no, interfaces, targetClass

1
2
3
4
5
6
7
8
9
10
11
<?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.xsd">
        
        <context:component-scan base-package="org.example"
                                scoped-proxy="interfaces"/>
	
 </beans>

示例

新建类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Component
// @Component("bean")
@Scope
// @Scope("prototype")
public class BeanAnnotation {
	
	public void say(String arg) {
		System.out.println("BeanAnnotation : " + arg);
	}
	
	public void myHashCode() {
		System.out.println("BeanAnnotation : " + this.hashCode());
	}
	
}

添加配置文件：

1
2
3
4
5
6
7
8
9
10
11
12
<?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.xsd" >
        
        <context:component-scan base-package="com.karonda.beanannotation"></context:component-scan>
        
 </beans>

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@RunWith(BlockJUnit4ClassRunner.class)
public class TestBeanAnnotation extends UnitTestBase {
	
	public TestBeanAnnotation() {
		super("classpath*:spring-beanannotation.xml");
	}
	
	@Test
	public void testSay() {
		// BeanAnnotation bean = super.getBean("bean");
		BeanAnnotation bean = super.getBean("beanAnnotation");
		bean.say("This is test.");
	}
	
	@Test
	public void testScpoe() {
		BeanAnnotation bean = super.getBean("beanAnnotation");
		bean.myHashCode();
		
		bean = super.getBean("beanAnnotation");
		bean.myHashCode();
	}
	
}

源码：learning-spring

展开全文 >>

学习 Spring (七) Resource

Spring入门篇 学习笔记

Resource: Spring 针对资源文件的统一接口

  • UrlResource: URL 对应的资源，根据一个 URL 地址即可构建
  • ClassPathResource: 获取类路径下的资源文件
  • FileSystemResource: 获取文件系统里面的资源
  • ServletContextResource: ServletContext 封装的资源，用于访问 ServletContext 环境下的资源
  • InputStreamResource: 针对于输入流封装的资源
  • ByteArrayResource: 针对于字节数组封装的资源

ResourceLoader: 所有的 application context 都实现了 ResourceLoader 接口

1
2
3
public interface ResourceLoader{
    Resource getResource(String location);
}

ResourceLoader 注入参数前缀：

前缀 例子 解释
classpath: classpath:com/myapp/config.xml 从 classpath 加载
file: file:/data/config.xml 从文件系统加载
http: http://myserver/logo.png 从 URL 加载
无 /data/config.xml 依赖于 ApplicationContext

示例

新建类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class MoocResource implements ApplicationContextAware  {
	
	private ApplicationContext applicationContext;
	
	@Override
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException {
		this.applicationContext = applicationContext;
	}
	
	public void resource() throws IOException {
		//Resource resource = applicationContext.getResource("classpath:config.txt");
		//Resource resource = applicationContext.getResource("file:E:\\project\\java\\demo\\learningspring\\src\\main\\resources\\config.txt");
		//Resource resource = applicationContext.getResource("https://www.cnblogs.com/victorbu/p/10430698.html");
		Resource resource = applicationContext.getResource("config.txt");
		System.out.println(resource.getFilename());
		System.out.println(resource.contentLength());
	}

}

添加配置文件：

1
2
3
4
5
6
7
8
9
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd" >
        
        <bean  id="moocResource" class="com.karonda.resource.MoocResource" ></bean>
	
 </beans>

添加测试类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@RunWith(BlockJUnit4ClassRunner.class)
public class TestResource extends UnitTestBase {
	
	public TestResource() {
		super("classpath:spring-resource.xml");
	}
	
	@Test
	public void testResource() {
		MoocResource resource = super.getBean("moocResource");
		try {
			resource.resource();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
}

源码：learning-spring

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家