spring学习记录

**

spring的基础简介

**
1、Spring是什么?

Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架,目的是用于简化企业应用程序的开发,它使得开发者只需要关心业务需求。常见的配置方式有三种:基于XML的配置、基于注解的配置、基于Java的配置。

2、Spring 的优点?

(1)spring属于低侵入式设计,代码的污染极低;

(2)spring的DI机制将对象之间的依赖关系交由框架处理,减低组件的耦合性;

(3)Spring提供了AOP技术,支持将一些通用任务,如安全、事务、日志、权限等进行集中式管理,从而提供更好的复用。

(4)spring对于主流的应用框架提供了集成支持。

AOP
AOP,一般称为面向切面,作为面向对象的一种补充,用于将那些与业务无关,但却对多个对象产生影响的公共行为和逻辑,抽取并封装为一个可重用的模块,这个模块被命名为“切面”(Aspect),减少系统中的重复代码,降低了模块间的耦合度,同时提高了系统的可维护性。可用于权限认证、日志、事务处理。

AOP实现的关键在于 代理模式,AOP代理主要分为静态代理和动态代理(JDK动态代理,cglib动态代理)。

AOP的重要名词:
**切面:**指被抽取出来的公共模块(如:日志文件,权限管理等)
2)连接点(Join point):指方法,在Spring AOP中,一个连接点 总是 代表一个被代理对象方法的执行。

(3)通知(Advice):在切面的某个特定的连接点(Join point)上执行的动作。通知有各种类型,其中包括“around”、“before”和“after”等通知。许多AOP框架,包括Spring,都是以拦截器做通知模型, 并维护一个以连接点为中心的拦截器链。

(4)切入点(Pointcut):切入点是指 我们要对哪些Join point进行拦截的定义。通过切入点表达式,指定拦截的方法,比如指定拦截add*、search*。

(5)引入(Introduction):引入就是在一个接口的基础上引入新的接口增强功能。

(6)目标对象(Target Object): 被一个或者多个切面(aspect)所通知(advise)的对象。也有人把它叫做 被通知(adviced) 对象。 既然Spring AOP是通过运行时代理实现的,这个对象永远是一个 被代理(proxied) 对象。

(7)织入(Weaving):指把增强应用到目标对象来创建新的代理对象的过程。Spring是在运行时完成织入。(切面的方法对切入点方法的不同组合)
————————————————
版权声明:本文为CSDN博主「a745233700」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/a745233700/article/details/80959716

pointcut:excecution=“修饰符 .返回值 .包名.类名.方法名(参数列表)”

在这里插入图片描
spring学习记录_第1张图片
JDK动态代理:

public class JDKDynamicProxy2 {

	 private Object target;

	    public JDKDynamicProxy2(Object target) {
	        this.target = target;
	    }
	public  T getProxy() {
		return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.println("proxy:"+proxy.getClass());
				System.out.println("method:"+method);
				log();
				 Object result = method.invoke(target, args);
				return result;
			}
		});
	}
	
	public void log() {
		System.out.println("日志信息....");
	}
	
	}

主函数:

public class Test03 {
public static void main(String[] args) {
	JDKDynamicProxy  proxy=new JDKDynamicProxy(new oracleLogin());
	login log=proxy.getProxy();
	log.dologin();
	
}
}

CGLIB动态代理:

public class CglibProxy {
	 private Object target;

	    public CglibProxy(Object target) {
	        this.target = target;
	    }
public T createProxy() {
	 
    return (T) Enhancer.create(target.getClass(), new MethodInterceptor() {
		
		@Override
		public Object intercept(Object arg0, Method method, Object[] arg2, MethodProxy arg3) throws Throwable {
			// TODO Auto-generated method stub
			System.out.println("proxy:"+arg0.getClass());
			System.out.println("method:"+method);
			log();
			Object result = method.invoke(target, arg2);
			return result;
		}
		
	});
	
}
public void log() {
	System.out.println("日志信息....");
}

主函数:

	CglibProxy proxy=new CglibProxy(new oracleLogin());
		login log=proxy.createProxy();
		log.dologin();

通知:

(1)前置通知(Before advice):在某连接点(join point)之前执行的通知,但这个通知不能阻止连接点前的执行(除非它抛出一个异常)。

(2)返回后通知(After returning advice):在某连接点(join point)正常完成后执行的通知:例如,一个方法没有抛出任何异常,正常返回。

(3)抛出异常后通知(After throwing advice):在方法抛出异常退出时执行的通知。 (它和返回后通知总是只执行一个)

(4)后通知(After (finally) advice):当某连接点退出的时候执行的通知(一般放在finally代码块中,一定执行)。

(5)环绕通知(Around Advice):指一个完整的动态代理过程,他可以完全控制切面的方法在什么时候执行,而且顺序一定,(1-4这个过程执行顺序可能会出错)

通知可以配置xml文件和注解两种方式:
1.配置xml的方式:

spring学习记录_第2张图片

2.注解的方式
(1)在spring配置文件中配置


(2.)

/*
 * 定义一个方法,用于声明切入点的表达式,一般的,该方法中无需添加任何其他的代码
 * 使用@Pointcut来声明切入点表达式
 * 后面其他的通知使用切入点方法名代替
 * 
 * */
//	@Pointcut("execution(* com.yc.aop.annotation.*.*(..))")
//	public void declareJoinPointExpression() {
//		
//	}
//	
//	
//	//前置通知 声明方法的前置通知 在通知目标方法前通知
//	
//	@Before("execution(* com.yc.aop.annotation.PersonBizImpl.add(..))")
//	public void beforeMenthod(JoinPoint joinPoint) {
//		String methodName=joinPoint.getSignature().getName();
//		//获取参数
//		Listlist=Arrays.asList(joinPoint.getArgs());
//		System.out.println("logging before method: "+methodName+"参数"+list);
//	}
//	
//	//后置通知  声明方法的后置通知 在执行方法后调用 (不管是否发生异常都执行)
//
//	@After("declareJoinPointExpression()")
//	public void afterMenthod(JoinPoint joinPoint) {
//		String methodName=joinPoint.getSignature().getName();
//		Listlist=Arrays.asList(joinPoint.getArgs());
//		System.out.println("logging agter method: "+methodName+"参数"+list);
//	}
//	//返回通知
//	@AfterReturning(value="declareJoinPointExpression()",returning="result")
//	public void afterReturnMethod(JoinPoint joinPoint,Object result) {
//		String methodName=joinPoint.getSignature().getName();
//		System.out.println("logging afterReturnMethod:"+methodName+"结果:"+result);
//	}
//	/*
//	 * 在目标方法出现异常时执行的代码
//	 * 可以访问异常对象:且可以指定出现特定异常的执行代码
//	 * 
//	 * */
//	@AfterThrowing(value="declareJoinPointExpression()",throwing="ex")
//	public void afterThrowingMenthod(JoinPoint joinPoint,Exception ex) {
//		String methodName=joinPoint.getSignature().getName();
//		System.out.println("logging afterThrowingMenthod:"+methodName+"异常信息:"+ex.getMessage());
//	}
	
	//环绕通知需要携带ProceedingJoinPoint参数
	/*类似动态代理全过程 ProceedingJoinPoint参数可以决定 是否执行目标方法
	 * */
	@Around("execution(* com.yc.aop.annotation.*.*(..))")
	public Object aroundMethod(ProceedingJoinPoint pjd) throws Throwable {
		Object result=null;
		Object methodName=pjd.getSignature().getName();
		try {
			//前置通知 声明方法的前置通知 在通知目标方法前通知
			System.out.println("logging before method: "+methodName+"参数"+Arrays.asList(pjd.getArgs()));
			//后置通知  声明方法的后置通知 在执行方法后调用 (不管是否发生异常都执行)
			result=pjd.proceed();
			System.out.println("logging after method: "+methodName+"参数"+result);
			
		}catch (Exception e) {
			// TODO: handle exception
			
		}
		return result;
	}
}
 
  

                            
                        
                    
                    
                    

你可能感兴趣的:(Spring,Spring)