Spring

Spring常见概念

2020-04-03  本文已影响0人  幽游不想吃饭

1.Spring是什么，它的作用是什么？

Spring是一个IOC（DI）和AOP的轻量级容器框架，它集成了很多模块，比如Web、AOP、测试和一些基本的工具，而且Spring可以很方便的集成其他框架，比如Mybatis、Hibernate等等。它简化了java开发，实现了代码的解耦。IOC是控制反转，DI是依赖注入，就是将对象的创建、初始化、销毁以及对象之间的依赖交给Spring来管理。AOP是面向切面编程，我们可以通过XML配置或者注解的方式在方法执行前、执行后、抛出异常后添加一些相应的业务逻辑，AOP经常用来做事务、日志、安全等相关功能。Spring主要是为了解决以前开发中的一些问题，从而提高开发效率，代码解耦。

Spring为了降低Java开发的复杂性，采用了以下四种策略：

2.什么是AOP？

答：AOP是面向切面编程，在不改变原来方法业务逻辑的基础上通过XML配置或者注解的方式给方法添加前置通知、后置通知、异常通知、最终通知、环绕通知，从而将很多业务方法都要用到的业务逻辑或功能添加到切点。我们通常用AOP做日志、事务、权限等功能。

3.AOP的XML配置实现方式和注解实现方式？

使用XML的配置方式实现AOP

首先需要一个增强类，这个类根据通知的类型去实现如MethodBeforeAdvice、AfterReturningAdvice 的接口，然后复写相应方法。再在XML中配置需要增强的方法的类的bean，增强类的bean，然后配置切点，也就是需要增强的方法，再将增强类和切点关联，再配置动态代理。

注解方式的实现AOP

首先导入包，然后使用@aspect配置切面类，使用@pointcut定义切点，@before等定义通知，最后在XML中开启注解扫描，开启aop注解。

4.AOP的实现原理？

AOP底层实现原理是代理设计模式。代理模式是通过代理控制对象的访问，可以详细访问某个对象的方法，在这方法调用前后处理。

代理分类分为静态代理和动态代理。

5.什么是静态代理？什么是动态代理？

静态代理

静态代理是指在代码运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就已经确定了。说白了就是程序员自己编写或者生成的代理类源码，再编译代理类。

public interface IUserDao {
    void save();
}

public class UserDao implements IUserDao {
    public void save() {
        System.out.println("已经保存数据...");
    }
}

//代理类
public class UserDaoProxy implements IUserDao {
    private IUserDao target;
    public UserDaoProxy(IUserDao iuserDao) {
        this.target = iuserDao;
    }
    public void save() {
        System.out.println("保存接口调用开始...");
        target.save();
        System.out.println("保存接口调用结束...");
        }
 }

动态代理

动态代理是在程序运行时通过反射机制动态生成字节码文件。动态代理分为JDK动态代理和Cglib动态代理。

JDK动态代理
/**
 * JDK动态代理
 * 每次生成动态代理类对象时,实现了InvocationHandler接口的调用处理器对象
 * <p>
 * 1.通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(…);
 * 2.通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类
     Class clazz = Proxy.getProxyClass(classLoader,new Class[]{…});
 * 3.通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
     Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
 * 4.通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入
     Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
 *
 * @author youyou
 */
public class InvocationHandlerImpl implements InvocationHandler {

/**
 * 这其实业务实现类对象，用来调用具体的业务方法
 */
private Object target;

/**
 * 通过构造函数传入目标对象
 *
 * @param target
 */
public InvocationHandlerImpl(Object target) {
    this.target = target;
}

/**
 * 代理具体功能在这里实现
 *
 */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Object result;
    System.out.println("调用开始处理");
    result = method.invoke(target, args);
    System.out.println("调用结束处理");
    return result;
}

public static void main(String[] args) throws SecurityException, IllegalArgumentException {
    //初始化委托类，构造代理类
    IUserDao userDao = new UserDao();
    InvocationHandlerImpl invocationHandlerImpl = new InvocationHandlerImpl(userDao);
    ClassLoader loader = userDao.getClass().getClassLoader();
    Class<?>[] interfaces = userDao.getClass().getInterfaces();
    //对Proxy指定ClassLoader和一组interface创建动态代理类
    IUserDao newProxyInstance = (IUserDao) Proxy.newProxyInstance(loader, interfaces, invocationHandlerImpl);
    newProxyInstance.save();
  }
}

JDK动态代理简单来说就是生成一个包装类对象，由于代理对象是动态的，所以是动态代理。由于我们需要增强，这个增强需要留给开发人员开发代码的，因此代理对象不能直接包含被代理对象，而是一个InvocationHandler，该对象包含被代理对象，并负责分发请求给代理对象，分发前后均可增强。从原理上看，JDK动态代理是对“对象”的代理。
JDK动态代理要求被代理类必须实现接口（Proxy.newProxyInstance第二个参数）。

Cglib动态代理
/**
 * Cglib动态代理实现
 */
 public class CglibProxy implements MethodInterceptor {

/**
 * 这里的目标类型为Object，则可以接受任意一种参数作为被代理类，实现了动态代理
 */
public Object getInstance(Class<?> clazz) {
    // 设置需要创建子类的类
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(clazz);
    enhancer.setCallback(this);
    return enhancer.create();
}

@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
    System.out.println("开启事物");
    Object result = proxy.invokeSuper(obj, args);
    System.out.println("关闭事物");
    // 返回代理对象
    return result;
}

public static void main(String[] args) {
      CglibProxy cglibProxy = new CglibProxy();
      UserDao userDao = (UserDao) cglibProxy.getInstance(UserDao.class);
      userDao.save();
    }
}

Cglib动态代理只需要一个类型clazz就可以产生一个代理对象， 所以说是“类的代理”，且创造的对象通过打印类型发现也是一个新的类型。

6. Spring的Bean的注入方式？

7. Spring中Bean的生命周期

Spring中bean的生命周期大致分为：实例化、初始化、运行、销毁

8. Spring中的常用注解？

9. 过滤器和拦截器的区别

过滤器

过滤器依赖Servlet容器，只能在容器初始化时调用一次，基于回调函数可以对几乎所有请求进行过滤。
应用场景：可以用来统一字符编码集、过滤敏感字符、访问权限控制。
实现方式：写一个过滤器类实现filter接口，复写init、dofilter、destory方法。

拦截器

拦截器依赖于Web框架，如果是使用SpringMVC就是依赖于SpringMVC框架。基于Java的反射机制，属于AOP的一种应用，由于拦截器基于Web框架，所以可以使用Spring的依赖注入进行业务操作。可以在controller生命周期之内多次调用。但是缺点是只能对controller请求进行拦截，对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理。
实现方式：实现HandlerInterceptor接口，并复写preHandle、postHandle、afterCompletion方法。

区别

执行顺序

执行顺序.png

10. Spring中Bean的常用作用域

11. Spring中的核心对象

BeanFactory

BeanFactory产生一个新的实例，可以实现单例模式，是Spring用来实例化、配置和管理Bean的。它使用的是懒加载，如果某个Bean中的某个属性没有注入，使用BeanFactory加载后要在第一次调用getBean方法才会抛出异常。

BeanWrapper

提供统一的get及set方法

ApplicationContext

ApplicationContext提供框架的实现，是BeanFactory的实现类，是对它功能的一个拓展，ApplicationContext使用的是迫切加载，这个类会自动解析我们配置的applicationContext.xml，然后根据我们配置的bean来new对象，将new好的对象放进一个Map中，键就是我们bean的id,值就是new的对象。

12. Spring FactoryBean和BeanFactory 区别

BeanFactory是个bean 工厂，是一个工厂类(接口)， 它负责生产和管理bean的一个工厂是ioc 容器最底层的接口，是个ioc容器，是spring用来管理和装配普通bean的ioc容器（这些bean成为普通bean）。
FactoryBean是个bean，在IOC容器的基础上给Bean的实现加上了一个简单工厂模式和装饰模式，是一个可以生产对象和装饰对象的工厂bean，由spring管理后，生产的对象是由getObject()方法决定的（从容器中获取到的对象不是“ FactoryBeanTest ” 对象）。

上一篇 下一篇

猜你喜欢

热点阅读