浅谈Spring框架

置顶 fighting！899

已于 2024-03-27 21:50:17 修改

阅读量742

点赞数 17

文章标签： spring java 后端

于 2024-03-21 20:43:43 首次发布

本文链接：https://blog.csdn.net/weixin_71921932/article/details/136914921

版权

一、什么是Spring？

Spring是一个开源框架，可以降低开发复杂度，提高开发效率，轻量级低耦合的框架。由于Spring的分层架构，可以自己选择整合其他组件，灵活性高

二、什么是IOC？

IOC 叫做控制反转，指的是通过Spring来管理对象的创建、配置和生命周期，这样相当于把控制权交给了Spring，不需要人工来管理对象之间复杂的依赖关系，这样做的好处就是解耦。在Spring里面，主要提供了 BeanFactory 和 ApplicationContext 两种 IOC 容器，通过他们来实现对 Bean 的管理。

BeanFactory采用延迟加载机制，初始化时间短，适用于资源有限或需要延迟加载的场景。ApplicationContext在启动时预先加载所有Bean对象，初始化时间较长，但在应用运行时能够更快地获取Bean对象，并提供了更多的功能和特性，适用于大多数应用场景。

BeanFactory（Bean工厂，顶层接口）： BeanFactory是Spring框架中最基本的IOC容器接口。它是一种轻量级的容器，采用延迟加载（懒加载）机制，即在需要获取Bean时才进行实例化和初始化。由于延迟加载的特性，BeanFactory的初始化时间较短，节约了系统资源。BeanFactory提供了基本的IOC功能，包括Bean的实例化、配置、装配以及管理Bean之间的依赖关系。
ApplicationContext： ApplicationContext是BeanFactory的子接口，也是Spring框架中更高级、功能更丰富的IOC容器。与BeanFactory相比，ApplicationContext在启动时会预先加载所有Bean对象，进行实例化和初始化。这使得ApplicationContext在应用运行时能够更快地获取Bean对象，提高了应用的性能。除了BeanFactory的功能外，ApplicationContext还提供了更多的特性，如国际化支持、事件传播、资源加载、AOP等。

三、什么是AOP？

AOP即面向切面编程，可以在不改变原有代码的基础上对目标方法进行无侵入式增强。AOP 基于动态代理的方式实现，如果是实现了接口的话就会使用 JDK 动态代理，反之则使用 CGLIB 代理，Spring中 AOP 的应用主要体现在事务、日志、异常处理等方面，通过在代码的前后做一些增强处理，可以实现对业务逻辑的隔离，提高代码的模块化能力，同时也是解耦。

四、JDK动态代理和CGliB代理区别有哪些？

Spring提供了两种方式来实现动态代理：JDK动态代理和CGLIB代理。

JDK动态代理：JDK动态代理是基于接口的代理，通过反射机制动态生成代理类。当目标对象实现了接口时，Spring会使用JDK动态代理来创建代理对象。JDK动态代理通过Proxy类和InvocationHandler接口实现。在运行时，通过Proxy类的newProxyInstance()方法生成代理对象，同时传入一个实现了InvocationHandler接口的代理处理器对象，用于处理代理对象的方法调用。

// 定义UserService接口，包含addUser方法
public interface UserService {
    void addUser();
}

// UserServiceImpl实现了UserService接口，实现了addUser方法
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("Add user");
    }
}

// MyInvocationHandler实现了JDK动态代理的InvocationHandler接口，用于对目标方法进行增强
public class MyInvocationHandler implements InvocationHandler {
    private Object target; // 目标对象

    public MyInvocationHandler(Object target) {
        this.target = target; // 初始化目标对象
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call"); // 在方法调用前输出信息
        Object result = method.invoke(target, args); // 调用目标对象的原始方法
        System.out.println("After method call"); // 在方法调用后输出信息
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl(); // 创建目标对象
        MyInvocationHandler handler = new MyInvocationHandler(target); // 创建代理处理器
        UserService proxy = (UserService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 类加载器
                target.getClass().getInterfaces(), // 目标对象实现的接口
                handler // 代理处理器
        );
        proxy.addUser(); // 调用代理对象的方法，实际会执行增强后的逻辑
    }
}

CGLIB代理：CGLIB代理是基于继承的代理，当目标对象没有实现接口时，Spring会使用CGLIB代理来创建代理对象。CGLIB代理通过字节码技术生成目标对象的子类，并重写父类的方法来实现增强功能。

// UserService类定义了一个简单的方法 addUser
public class UserService {
    public void addUser() {
        System.out.println("Add user");
    }
}

// MyMethodInterceptor实现了CGLIB的MethodInterceptor接口，用于对目标方法进行增强
public class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method call"); // 在方法调用前输出信息
        Object result = proxy.invokeSuper(obj, args); // 调用被代理对象的原始方法
        System.out.println("After method call"); // 在方法调用后输出信息
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer(); // 创建Enhancer对象，用于生成代理类
        enhancer.setSuperclass(UserService.class); // 设置父类为UserService，生成的代理类会继承UserService
        enhancer.setCallback(new MyMethodInterceptor()); // 设置方法拦截器，用于对目标方法进行增强
        UserService proxy = (UserService) enhancer.create(); // 创建代理对象
        proxy.addUser(); // 调用代理对象的方法，实际会执行增强后的逻辑
    }
}

五、Spring中有哪些设计模式？

1.代理模式：

所谓代理，是指它与被代理对象实现了相同的接口，客户端必须通过代理才能与被代理的目标类进行交互，而代理一般在交互的过程中（交互前后），进行某些特定的处理，比如在调用这个方法前做前置处理，调用这个方法后做后置处理。代理又分为静态代理和动态代理两种方式，Spring 的 AOP 采用的是动态代理的方式Spring 通过动态代理对类进行方法级别的切面增强，动态生成目标对象的代理类，并在代理类的方法中设置拦截器，通过执行拦截器中的逻辑增强了代理方法的功能，从而实现 AOP。

2.单例模式：

单例模式是指一个类在整个系统运行过程中，只允许产生一个实例。在Spring中，Bean 可以被定义为两种模式：Prototype（多例）和Singleton（单例），Spring 默认是单例模式。那么Spring是如何实现单例模式的呢？答案是通过单例注册表的方式，具体来说就是使用了HashMap

public class DefaultSingletonBeanRegistry {
    
    //使用了线程安全容器ConcurrentHashMap，保存各种单实例对象
    private final Map singletonObjects = new ConcurrentHashMap;

    protected Object getSingleton(String beanName) {
    //先到HashMap中拿Object
    Object singletonObject = singletonObjects.get(beanName);
    
    //如果没拿到通过反射创建一个对象实例，并添加到HashMap中
    if (singletonObject == null) {
      singletonObjects.put(beanName,
                           Class.forName(beanName).newInstance());
   }
   
   //返回对象实例
   return singletonObjects.get(beanName);
  }
}

3.模板模式：

主要是一些对数据库操作的类用到，比如 JdbcTemplate、JpaTemplate，因为查询数据库的建立连接、执行查询、关闭连接几个过程，非常适用于模板方法。

六、Spring为什么默认是单例？如何保证单例Bean线程安全？

1、为什么Spring默认是单例的？

Spring默认采用延迟初始化（懒汉式加载）策略，即只有在第一次被请求时才会创建Bean实例。这样可以避免在容器启动过程中创建大量的对象，提高应用程序的启动性能。

2、Spring中如何保证单例Bean的线程安全？

1.改变Bean的作用域

通过将Bean的作用域改为原型，可以保证每次获取Bean都会返回一个新的实例，从而避免了多线程之间共享一个Bean实例的问题。具体的做法就是在Bean类上的@Bean注解中使用@scope("prototype")来指定Bean的作用域。

2.线程安全同步机制（加锁）

对于一些需要共享状态的Bean，可以采取同步机制来保护共享状态，避免多个线程同时修改同一个Bean实例的状态。一般来说使用synchronized、Reentrantlock等关键字或锁对象来同步存取共享状态的代码。

3.使用ThreadLocal

如果只有某一个Bean类的一部分需要进行同步，可以考虑将这部分“状态”信息移除到清秀级别的Threadlocal中，这样每个线程都会有自己的副本，避免多线程之间共享状态的问题。

4.使用并发集合类

Java并发包中提供了很多线程安全的Concurrent类，例如ConcurrentHashMap、CopyOnWriteArrayList等。这些类内部实现了各种同步机制，可以保证多线程下的正确性。所以，在处理多线程环境下的共享Bean时，也可以使用这些线程安全类来替代普通的集合类，从而避免多个线程访问同一个Bean实例时产生的并发问题。