23-Spring

Sping和一个开源框架，能够和其余框架一块儿使用，解决对象建立以及对象之间依赖关系的一种框架；

Spring有7大模块

    1：SpringCore

    2：SpringDao

    3：SrpingROM

    4：SpringWeb

    5：Springcontext

    6：SpringAOP

    7：SpringWebMvc

 

Spring默认是单例的

SpringIOC

    SpringIOC容器是Spring的核心内容

    做用：建立对象、处理对象的依赖关系

    SpringIOC的原理：dom4j解析+反射机制

容器建立对象：

 建立对象, 有几种方式：

    1） 调用无参数构造器

    2） 带参数构造器

    3） 工厂建立对象

    工厂类，静态方法建立对象

    工厂类，非静态方法建立对象

DL（依赖注入）的方式：

    1： 经过构造函数

    2：经过set方法给属性注入值

    3：p名称空间

    4：注解

SpringAOP

    面向切面编程

    SpringAOP实现原理：代理模式

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

    注意：AOP不是一种技术，其实是编程思想。凡是符合AOP思想的技术，均可以当作是AOP的实现。

Aop，  aspect object programming  面向切面编程
	功能： 让关注点代码与业务代码分离！
关注点,
	重复代码就叫作关注点；
切面，
	 关注点造成的类，就叫切面(类)！
	 面向切面编程，就是指 对不少功能都有的重复的代码抽取，再在运行的时候网业务方法上动态植入“切面类代码”。
切入点，
	执行目标对象方法，动态植入切面代码。
	能够经过切入点表达式，指定拦截哪些类的哪些方法； 给指定的类在运行的时候植入切面类代码。

实现方式：

    1：注解

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>  开启事物注解权限

4) 使用注解
@Aspect							指定一个类为切面类		
@Pointcut("execution(* com.itmayiedu.service.UserService.add(..))")  指定切入点表达式

@Before("pointCut_()")				前置通知: 目标方法以前执行
@After("pointCut_()")					后置通知：目标方法以后执行（始终执行）
@AfterReturning("pointCut_()")		    返回后通知： 执行方法结束前执行(异常不执行)
@AfterThrowing("pointCut_()")			异常通知:  出现异常时候执行
@Around("pointCut_()")				环绕通知： 环绕目标方法执行

 

@Component
@Aspect
public class Aop {
	@Before("execution(* com.itmayiedu.service.UserService.add(..))")
	public void begin() {
		System.out.println("前置通知");
	}

	@After("execution(* com.itmayiedu.service.UserService.add(..))")
	public void commit() {
		System.out.println("后置通知");
	}

	@AfterReturning("execution(* com.itmayiedu.service.UserService.add(..))")
	public void afterReturning() {
		System.out.println("运行通知");
	}

	@AfterThrowing("execution(* com.itmayiedu.service.UserService.add(..))")
	public void afterThrowing() {
		System.out.println("异常通知");
	}

	@Around("execution(* com.itmayiedu.service.UserService.add(..))")
	public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
       System.out.println("我是环绕通知-前");
       proceedingJoinPoint.proceed();
       System.out.println("我是环绕通知-后");
	}

}

2：XML

XML方式实现AOP编程

Xml实现aop编程：
	1） 引入jar文件  【aop 相关jar， 4个】
	2） 引入aop名称空间
	3）aop 配置
		* 配置切面类 （重复执行代码造成的类）
		* 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:p="http://www.springframework.org/schema/p"
    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">
	
	<!-- dao 实例 -->
	<bean id="userDao" class="com.itmayiedu.UserDao"></bean>
	<bean id="orderDao" class="com.itmayiedu.OrderDao"></bean>
	
	<!-- 切面类 -->
	<bean id="aop" class="com.itmayiedu.Aop"></bean>
	
	<!-- Aop配置 -->
	<aop:config>
		<!-- 定义一个切入点表达式： 拦截哪些方法 -->
		<aop:pointcut expression="execution(* com.itmayiedu.*.*(..))" id="pt"/>
		<!-- 切面 -->
		<aop:aspect ref="aop">
			<!-- 环绕通知 -->
			<aop:around method="around" pointcut-ref="pt"/>
			<!-- 前置通知： 在目标方法调用前执行 -->
			<aop:before method="begin" pointcut-ref="pt"/>
			<!-- 后置通知： -->
			<aop:after method="after" pointcut-ref="pt"/>
			<!-- 返回后通知 -->
			<aop:after-returning method="afterReturning" pointcut-ref="pt"/>
			<!-- 异常通知 -->
			<aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
			
		</aop:aspect>
	</aop:config>
</beans>