spring总结

最新推荐文章于 2024-07-28 19:41:52 发布

qq_45960341

最新推荐文章于 2024-07-28 19:41:52 发布

阅读量57

点赞数

文章标签： java spring

本文链接：https://blog.csdn.net/qq_45960341/article/details/119349635

版权

spring总结

1、 spring的优点

ioc方便解耦，简化开发
aop不改变源代码，在其基础上增加功能
test：方便测试
方便与其他程序整合
降低API的开发难度

2、 spring-ioc

2.1. xml解析

通过xml配置创建对象

 <bean id=" " class=" "></bean>

2.2. 工厂模式

定义一个中间静态函数，降低其耦合度

2.3. 反射

通过反射创建对象
解释一下java反射机制：
java在运行状态下，对任意一个类都能知道这个类所有的属性和方法，对于任意一个对象都能任意调用他的属性和方法，这种动态获取信息，以及动态调用对象的方法的功能称为java语言的反射机制

  通过反射获取java对象的方式：

1、第一种方式获取Class对象  
        Student stu1 = new Student();//这一new 产生一个   Student对象，一个Class对象。
       Class stuClass = stu1.getClass();//获取Class对象
       System.out.println(stuClass.getName());

2、第二种方式获取Class对象
         Class stuClass2 = Student.class;
         System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个

3、第三种方式获取Class对象
		try {
			Class stuClass3 = Class.forName("fanshe.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
			System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}

2.3. ioc的接口

IOC基于ioc容器，底层及时对象工厂

1、BeanFactory：spring内部内部使用接口，不提供给开发人员使用，加载xml解析不会创建对象，只有创建对象才会getBean。

2、ApplicationContext：是BeanFactory的子接口，功能强大，开发人员可使用，加载配置就会创建对象

3.ApplicationContext有一些特别的实现类
特别是ClassPathXmlApplicationContext，在src目录下可以写文件名
如果是FileSystemXmlApplicationContext，在src目录下，必须写绝对路径

//1 加载spring配置文件
ApplicationContext context =new ClassPathXmlApplicationContext("bean2.xml");

//2 获取配置创建的对象
UserService userService = context.getBean("userService", UserService.class);

2.4. ioc-bean管理

2.4.1、 bean的作用域

   spring-ioc默认是单例的

2.4.2、 bean的生命周期

在这里插入图片描述

3、 spring-aop

3.1、 spring-aop的概念

（1）、面向切面编程，利用aop可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑的各个部分的耦合度降低，提高代码的重用信，同时提高了开发效率
（2）、通俗描述，不通过修改原代码的方式，在主干功能里添加新功能
（3）、使用登录功能解释aop
在这里插入图片描述

3.2、 jdk动态代理的详解

3.3、 aop的底层原理

a）AOP 底层使用动态代理，动态代理有两种情况：

第一种有接口情况，使用 JDK 动态代理；创建接口实现类代理对象，增强类的方法在这里插入代码片

第二种没有接口情况，使用 CGLIB 动态代理；创建子类的代理对象，增强类的方法

3.4、 aop（jdk动态代理）

1）使用 JDK 动态代理，使用 Proxy 类里面的方法创建代理对象

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)

第一参数，类加载器
第二参数，增强方法所在的类，这个类实现的接口，支持> 多个接口
第三参数，实现这个接口 InvocationHandler，创建代理对> 象，写增强的部分

3.5、 AOP（术语）

a）连接点：类里面哪些方法可以被增强，这些方法称为连接点

b）切入点：实际被真正增强的方法称为切入点

c）通知（增强）：实际增强的逻辑部分称为通知，且分为以下五种类型：

1）前置通知 2）后置通知 3）环绕通知 4）异常通知 5）最终通知

d）切面：把通知应用到切入点过程

3.6、 AOP 操作（AspectJ 注解）

//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {}
//被增强的类
@Component
public class User {}

//4、配置不同类型的通知
@Component
@Aspect //生成代理对象
public class UserProxy {

  //相同切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void pointdemo() {

}

//前置通知
//@Before注解表示作为前置通知
@Before(value = "pointdemo()")//相同切入点抽取使用！
public void before() {
    System.out.println("before.........");
}

//后置通知（返回通知）
@AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void afterReturning() {
    System.out.println("afterReturning.........");
}

//最终通知
@After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void after() {
    System.out.println("after.........");
}

//异常通知
@AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void afterThrowing() {
    System.out.println("afterThrowing.........");
}

//环绕通知
@Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("环绕之前.........");

    //被增强的方法执行
    proceedingJoinPoint.proceed();

    System.out.println("环绕之后.........");
}

}