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

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

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

• 基于POJO的轻量级和最小侵入性编程。不需要强迫实现Spring规范的接口和类从而对代码和框架造成强耦合，最坏的情况是，即使一个类使用了Spring注解，但它仍然是POJO(Plain old java object 简单java对象)
• 通过依赖注入和面向接口实现松耦合。将类之间的关系通过依赖注入关联，将对象的创建和管理以及对象间的依赖交给Spring容器维护，每个实例只需要负责执行，执行内容由Spring决定
• 基于切面和管理进行声明式编程。应用切面实现代码复用(模板+骨架，骨架上有卡槽，木块可以插入骨架的卡槽中，实现代码复用)，减少不必要功能对主逻辑的侵入和代码污染。
• 通过切面和模板减少样板式代码。将样板式代码进行封装(比如JDBC本身存在大量样板式代码)，只需要写核心逻辑即可。

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的注入方式？

• 属性注入：通过setXXX( )方法注入bean的属性值或依赖对象
• 构造函数注入
• 工厂方法注入（包括非静态工厂或静态工厂，区别就是在创建Bean实例的时候需不需要创建一个工厂类实例从而调用工厂类创建Bean的方法）

7. Spring中Bean的生命周期

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

• 通过构造器或工厂方法创建bean的实例，此时会加载类，执行类加载的加载、验证、准备、解析、初始化这几个步骤
• 为bean的属性设置值，并注入对其他bean的引用
• 调用bean的初始化方法
• 运行：初始化完成后bean就可以使用了
• 销毁：当容器关闭，调用bean的销毁方法

8. Spring中的常用注解？

• @Controller：指明该类是一个controller
• @Service：指明该类是一个service
• @Repository：指明该类是一个dao
• @Componet：指明这是一个组件类，交给Spring管理
• @RequestMapping：申明类或方法匹配的URL
• @Autowired：通过反射自动装配

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

过滤器

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

拦截器

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

区别

• 过滤器基于函数回调，拦截器基于反射
• 过滤器依赖于Servlet容器，拦截器依赖于Web框架
• 过滤器几乎对所有请求起作用，拦截器只对action请求起作用
• 过滤器只能在容器初始化的时候被调用一次，拦截器可以在action的生命周期中被调用多次
• 拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

执行顺序

执行顺序.png

10. Spring中Bean的常用作用域

• Singleton(单例)：使用此作用域的Bean在Spring容器中只有一个实例，即无论多少个Bean引用它都指向同一个对象。(默认作用域)
• Prototype(原型)：每次通过Spring容器获取Bean(注入或者通过应用上下文获取)的时候都会创建一个新的Bean实例。
• Session(会话)：在Web应用中，为每个回话创建一个bean实例(购物车)。
• Request(请求)：在Web应用中，为每个请求创建一个bean实例。
• global-session:全局会话，所有会话共享一个实例。

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 ” 对象）。