Spring Demo

Spring是什么：

Spring是一个轻量级的DI和AOP容器框架，非侵入式，基于spring开发的应用一般不依赖于spring的类。

 

DI:称作依赖注入(Dependency Injection),和 IOC（控制反转）一个概念，创建被调用对象有Spring来完成，在容器实例化对象的时候主动的将被调用者（或者说它的依赖对象）注入给调用对象，因此又叫依赖注入。

 

AOP：Spring对面向切面编程提供了强有力的支持，通过它让我们将业务逻辑从应用服务（如事务管理）中分离出来，实现了高内聚开发，应用对象只关注业务逻辑，不再负责其它系统问题（如日志、事务等）。

 

容器：Spring是个容器，因为它包含并且管理应用对象的生命周期和配置。如对象的创建、销毁、回调等。

框架：Spring作为一个框架，提供了一些基础功能，（如事务管理，持久层集成等），使开发人员更专注于开发应用逻辑。

 

Spring的优点

1.使用Spring的IOC容器，将对象之间的依赖关系交给Spring，降低组件之间的耦合性，让我们更专注于应用逻辑

2.可以提供众多服务，事务管理，WS等。

3.AOP的很好支持，方便面向切面编程。

4.对主流的框架提供了很好的集成支持，如Hibernate,Struts2,JPA等

5.Spring DI机制降低了业务对象替换的复杂性。

6.Spring属于低侵入，代码污染极低。

7.Spring的高度可开放性，并不强制依赖于Spring，开发者可以自由选择Spring部分或全部

 

下面直接列举spring demo

 

public interface Axe {
	public String chop();
}

 

public interface Person {
	public void useAxe();
}

 

@Service
public class StoneAxe implements Axe {

	public String chop() {
		return "慢";
	}
}

 

//@Service
public class SteelAxe implements Axe {

	public String chop() {
		return "快";
	}
}

 

@Service
public class Chinese implements Person {

	@Resource
	private Axe axe;

	public void setAxe(Axe axe) {
		this.axe = axe;
	}

	public void useAxe() {
		System.out.println(axe.chop());
	}
}

 

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"
	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="springDemo"></context:component-scan>
	<context:annotation-config />
</beans>  

 

客户端调用

	@Test
	public void springTestAxe() {

		ApplicationContext context = new ClassPathXmlApplicationContext(
				"bean.xml");
		Chinese chinese = context.getBean("chinese", Chinese.class);
		chinese.useAxe();
	}

 

maven

jar包 

<dependencies>    
    	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit-dep</artifactId>
		<version>4.11</version>
		<scope>test</scope>
	</dependency>
        
    	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>4.1.4.RELEASE</version>
	</dependency>
    
    	<dependency>
		<groupId>javax.annotation</groupId>
		<artifactId>javax.annotation-api</artifactId>
		<version>1.2</version>
	</dependency>
    
    	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.8.5</version>
	</dependency>
</dependencies>

 

 

日志管理 AOP

 

<?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="springDemo"></context:component-scan>
	<context:annotation-config />
	 
    	<aop:config>
		<aop:pointcut id="servicepointcut"
			expression="execution(* springDemo.*.*.*(..))" />
		<aop:aspect id="loggeraspect" ref="optLogger">
			<aop:before method="logger" pointcut-ref="servicepointcut" />
		</aop:aspect> 
	</aop:config> 
	<!-- 
		proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，  
		当配为<aop:aspectj-autoproxy poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。
		不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。 
	 -->

	<aop:aspectj-autoproxy proxy-target-class="true"/>  
</beans>    

 

日志处理类

@Service
public class OptLogger {

//	public void logger() {
//		System.out.println("开始记录日志。。。");
//	}

	public Object logger(ProceedingJoinPoint pjp) throws Throwable {
		// proceed()方法有执行目标对象的功能
		Object obj = pjp.proceed();
		// 获取方法名
		String method = pjp.getSignature().getName();
		// 获取目标对象类名称
		String clazzName = pjp.getTarget().getClass().getName();

		String key = clazzName + "." + method;

		PropertiesUtil.getInstance("opt.properties");

		System.out.println("执行了" + PropertiesUtil.getProperty(key));
		return obj;
	}
}

 

PropertiesUtil  用于读取配置文件

public class PropertiesUtil {

	static Properties props = new Properties();

	private PropertiesUtil() {
	}

	public static Properties getInstance(String path) throws IOException {
		props.load(PropertiesUtil.class.getClassLoader().getResourceAsStream(
				path));
		return props;
	}

	public static String getProperty(String key) {
		String val = "";
		if (props != null) {
			String prop = props.getProperty(key);
			if (prop != null) {
				val = prop;
			}
		}
		return val;
	}
}

 

opt.properties 文件

springDemo.inter.impl.StoneAxe.chop=\u67E5\u8BE2

 

客户端调用代码不变

 

通知类型

 

1)  前置通知
<aop:before>
  在目标方法调用之前执行。不能阻止后续执行，除非抛异常
2)  后置通知
<aop:after-returning>
  在目标方法调用之后执行。目标方法正常结束才执行。
3)  最终通知
<aop:after>

  在目标方法调用之后执行。目标方法正常或异常都执行。
4)  异常通知
<aop:after-throwing>
  在目标方法调用发生异常之后执行。
5)  环绕通知
<aop:around>
  在目标方法调用之前和之后执行。
 
这 5 种类型的通知，在内部调用时这样组织
  try{
        调用前置通知
        环绕前置处理
        调用目标对象方法
        环绕后置处理
        调用后置通知
  }catch(Exception e){
    调用异常通知
  }finally{
    调用最终通知
  }