spring学习记录

r囧r小猫 2024-04-18 20:48 4阅读 0赞

\*\*

## spring的基础简介 ##

\*\*  
**1、Spring是什么?**

Spring是一个轻量级的IoC和AOP容器框架。用于简化企业应用程序的开发。

**2、Spring 的优点？**

（1）spring从大小和开销上都属于轻量级；

（2）spring的控制反转将对象之间的依赖关系交由框架处理，减低组件的耦合性；

（3）Spring提供了AOP技术，支持将一些通用任务，如安全、事务、日志、权限等进行集中式管理，与业务逻辑代码进行分离也提高了代码的复用。

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

**IOC**：ioc实际是map（key，value）结构的容器，里面存着各种对象（xml配置的，加上@controller，@servicce，@component，@repository这些注解标识的对象）项目启动时会读取配置文件通过全限定名反射创建对象或者通过扫描到打上上述注解到的类通过反射的方式创建对象放到map中。  
这个时候map里面就有我们需要的各个对象了，我们项目需要这些对象时就通过依赖注入的方式去在对应位置使用这些对象，

没有用到ioc容器前，对于A对象依赖B对象，我们都是通过在A对象需要B对象的地方主动的创建依赖对象B，使用IOC容器后A,B对象的生命周期和依赖关系都交由容器管理，IOC容器在程序运行中动态的将B对象注入到A需要的地方，这样对于A对象对于依赖的控制权由主动变成了被动也是为什么叫控制反转的原因。  
DI（依赖注入）：  
依赖注入是实现IOC的方法，由IOC容器在运行期间，动态的将某种依赖进行注入到对象中。

**AOP**：  
AOP（面向切面编程），作为面向对象（OOP）的一种补充。OOP通过引入继承，封装，多态等概念打造了对象间纵向的层次关系,但对于对象横向的关系例如分散在许多对象中的日志功能，而它与所散布到的对象的核心功能毫无关系，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用，AOP却可以通过将对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），来减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。可用于权限认证、日志、事务处理。

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

**静态代理模式**：静态代理是在程序运行前就已经存在代理类的字节码文件，代理类和原始类的关系在运行前就已经确定。

一般通过代理类和被代理类实现同一个接口，通过在代理类里面组合被代理类对象，在调用被代理类方法前后进行一些与业务逻辑无关的操作来增强被代理类的方法。  
缺点：  
静态代理虽然保证了业务类只需关注逻辑本身，代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理。  
再者，如果增加一个方法，除了实现类需要实现这个方法外，所有的代理类也要实现此方法。增加了代码的维护成本。

**动态代理模式**：动态代理类的源码是在程序运行期间通过JVM反射等机制动态生成，代理类和委托类的关系是运行时才确定的。

**JDK动态代理:**

public class JDKDynamicProxy2 {
    
    	 private Object target;
    
    	    public JDKDynamicProxy2(Object target) {
    	        this.target = target;
    	    }
    	public <T> 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();
    	
    }
    }

JDK动态代理是通过生成了一个类去实现接口来代理的所以使用jdk生成的动态代理的前提是目标类必须有实现的接口。但这里又引入一个问题,如果某个类没有实现接口,就不能使用JDK动态代理,

**CGLIB动态代理:**

public class CglibProxy {
    	 private Object target;
    
    	    public CglibProxy(Object target) {
    	        this.target = target;
    	    }
    public <T>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();

Cglib是通过动态生成被代理类子类的方式实现动态代理。  
Cglib使用的前提是目标类不能为final修饰。因为final修饰的类不能被继承。

**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=“修饰符 .返回值 .包名.类名.方法名(参数列表)”

在这里插入图片描  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbjEyMTQwMDA5OTk_size_16_color_FFFFFF_t_70]

**通知:**

（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的方式:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbjEyMTQwMDA5OTk_size_16_color_FFFFFF_t_70 1]

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

<aop:aspectj-autoproxy/>

(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();
    //		//获取参数
    //		List<Object>list=Arrays.asList(joinPoint.getArgs());
    //		System.out.println("logging before method: "+methodName+"参数"+list);
    //	}
    //	
    //	//后置通知  声明方法的后置通知 在执行方法后调用 (不管是否发生异常都执行)
    //
    //	@After("declareJoinPointExpression()")
    //	public void afterMenthod(JoinPoint joinPoint) {
    //		String methodName=joinPoint.getSignature().getName();
    //		List<Object>list=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 中bean的生命周期**：  
1.根据@componetscan注解配置的包扫面路径去寻找路径中带有  
@component，@controller，@service，@respority等注解的类或者xml配置的bean根据推断构造方法去实例化对象。

2.对实例化后的对象经行一个属性填充，也就是根据属性或者属性的set方法或者构造器上的@autowirted，@resource注解将依赖的对象注入到属性上。

3.如果Bean实现了各种的xxxAware接口，如ApplicationContextAware，BeanNameAware，BeanFactoryAware等Aware接口，如果实现了就执行其重写的方法来获取容器的一些信息。

4.如果Bean实现了BeanPostProcessor接口，Spring就将调用他们的postProcessBeforeInitialization()方法。

5.如果Bean实现了InitializingBean接口或者用@PostConstruct注解标明了初始化方法，就调用其实现的afterPropertiesSet方法或者自定义方法去进行一些初始化bean的操作（如类中某些字段的值依赖于对数据库的查询则可以在此方法中初始化）

6.如果Bean 实现了BeanPostProcessor接口，Spring就将调用他们的postProcessAfterInitialization()方法。

7.如果Bean需要进行Aop操作，首先去加载容器中所有切面也就是@Aspect注解标注的类，查看里面定义的切点中execution是否与bean匹配  
如果匹配则使用动态代理生成代理对象交给容器，否则将之前实例化的原对象交给容器。

8.在容器销毁前，如果bean实现了DisposableBean接口，Spring将调用它的destory()接口方法，同样，如果bean使用了@PreDestroy注解 声明销毁方法，该方法也会被调用。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbjEyMTQwMDA5OTk_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/3804e5229d3745ab9b7c51c9187f635e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbjEyMTQwMDA5OTk_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ffa7236864954b22b6cc0886b9debf2b.png