新手小菜鸟上路

Spring和SpringMVC总结

一、Spring

IoC(Inversion of Control)中文名称：控制反转（对象的创建交给Spring管理）。

DI(dependency injection )依赖注入。

容器（Container）：放置所有被管理的对象。

beans：容器中所有被管理的对象称为beans。

一.Spring IOC

1. 介绍

控制反转，对象的创建交给Spring管理。

2. Bean实例化的两种方式（面试题）

2.1.BeanFactory（spring创建对象）

通过构造方法进行实例化。默认使用无参构造。

创建方式：

标签配置。在Spring.xml配置中进行bean对象的创建。

@Component及子注解管理对象，配合 ComponentScan的扫描。

@Service
public class UserServiceImpl implements UserService{
  
}

@Bean修饰的方法，方法的返回值交由spring管理，方法名为key。
@Import 指定的类由spring管理。

2.2.FactoryBean（使用自定义的工厂类创建对象）

分为静态工厂和实例工厂两种方式。静态工厂和实例工厂类最主要的区别是，创建bean的方法是static修饰的。

1.自定对象工厂类。

public class PeopleFactory {
    People peo = new People();
    public People getInstance(){
        return peo;
    }
}

2.工厂交由spring管理，从工厂方法中获取对象交由spring管理。

2.3.bean标签的scope属性（面试题）

Spring中的scope控制的是Bean的有效范围。一共有6个可取值。

二.Spring DI（依赖注入）

1.手动注入(spring.xml中进行配置)

1.构造注入（依赖于构造方法完成属性赋值）

2.设置注入（依赖于set方法完成属性赋值）

2.自动注入（使用注解）

自动注入指的都是bean之间的自动注入。能够自动注入必须保证Spring 容器中包含能被自动注入的bean。

1.两种方式进行配置：

在根标签中配置default-autowire属性。

在标签中配置autowire属性，和default-autowire取值相同。

2.属性取值

byName：根据bean的名字自动注入，依赖于set方法。

byType：通过类的类型自动注入。

constructor：通过构造方法进行注入。调用有参构造方法完成对象创建及属性自动注入。

3.@Autowired注解（自动注入）

用在类上的注解，先根据类型找，类型出现多个，再根据名字找。

1.特殊用法

用在属性上，使用反射进行注入。

用在set方法上，使用set方法注入。

用在有参构造方法上，使用有参构造进行注入。

2.特点

注解所在的bean和注入的bean都为spring容器管理的bean。

@Resouce（非spring注解）：先根据名字找，没有找到，再根据类型找。

三.单例设计模式(面试中笔试题）

只创建一个对象的设计模式。

1. 饿汉式

/*
    单例：希望类只有一个
    核心思想：
        1. 构造方法私有
        2. 对外提供一个能够获取对象的方法。
    饿汉式：
        优点：实现简单
        缺点：无论是否使用当前类对象，加载类时一定会实例化。
 */
public class Singleton {
    // 之所以叫做饿汉式：因为类加载时就创建了对象
    private static Singleton singleton = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return singleton;
    }
}

2. 懒汉式

/**
 * 核心思想：
 * 1. 构造方法私有。
 * 2. 对外提供一个能够获取对象的方法。
 *
 * 懒汉式优点和缺点：
 *  优点：
 *      按需创建对象。不会在加载类时直接实例化对象。
 *  缺点：
 *      写法相对复杂。
 *      多线程环境下，第一次实例化对象效率低。
 */
public class Singleton2 {
    //懒汉式：不会立即实例化
    private static Singleton2 singleton2;
    private Singleton2() {}
    public static Singleton2 getInstance() {
        if (singleton2 == null) {// 不是第一次访问的线程，直接通过if判断条件不成立。直接return
            synchronized (Singleton2.class) {
                if(singleton2==null) {// 防止多个线程已经执行到synchronized
                    singleton2 = new Singleton2();
                }
            }
        }
        return singleton2;
    }
}

四.循环依赖问题(重要面试题)

1.介绍

循环注入即多个类相互依赖，产生了一个闭环。

2. 解决循环依赖（三级缓存）

一级缓存(singletonObjects)：存放 实例化、属性注入和初始化完成的对象。

二级缓存(earlySingletonObjects)：存放早期暴露出来的Bean对象，实例化和属性注入完成的对象。

三级缓存（singletonFactories）：存放实例化完成的对象。存放bean创建工厂，以便于后面扩展有机会创建代理对象。

单例模式创建对象的步骤：

实例化：调用对象的构造方法实例化对象。

属性注入：填充属性，这一步主要是对bean的依赖属性进行填充。

初始化：属性注入后，执行自定义初始化操作。

五.BeanFactory和ApplicationContext（经典面试题）

1. BeanFactory接口（懒汉式）

BeanFactory是Spring中的顶级接口，接口中定了Spring容器最基本功能。是Spring IoC的最核心接口。

ApplicationContext的getBean方法其实就是BeanFactory的方法。

BeanFactory是在调用getBean方法的时候才实例化Bean。(懒汉式)

BeanFactory最常用实现类是XmlBeanFactory。但是从Spring 3.1 版本开始，使用DefaultListableBeanFactory和XMLBeanDefinitionReader替代。

2. ApplicationContext接口（饿汉式）

BeanFactory的子接口。比BeanFactory的功能更加强大，除了BeanFactory的功能，还包含了：

AOP 功能

国际化（MessageSource）

访问资源，如URL和文件（ResourceLoader）

消息发送机制（ApplicationEventPublisher）

Spring集成Web时的WebApplicationContext

ApplicationContext是在加载配置文件后立即实例化Bean。(饿汉式)

在使用时ApplicationContext时多使用ClassPathXmlApplicationContext。

六.动态代理设计模式

动态创建代理对象。

1.JDk动态代理

JDK动态代理是基于接口。先创建接口，然后创建被代理对象类。

 //JDK动态代理
   /*
    功能：
          JDK动态代理为类创建代理对象，实现目标对象功能的增强
          JDK动态代理为接口创建实现类
    */

    /*
    Proxy.newProxyInstance中的参数 
        参数一：类加载
        参数二：接口的类对象（JDK动态代理基于接口实现）
        参数三：运行时底层实现select()方法【该过程看不到】，实现的方法中调用了 invoke()
    */
    @Test
    public void test01() {
        //创建被代理对象
        UserServicesImpl userServicesImpl = new UserServicesImpl();
        UserService userService = (UserService) Proxy.newProxyInstance(
                Test2.class.getClassLoader(),//
                UserServicesImpl.class.getInterfaces(),//必须为接口的类对象
                new InvocationHandler() {//
                    @Override
                    /*
                      invoke方法中的参数：
                          参数一：代理对象
                          参数二：目标方法（被代理方法）
                          参数三：目标方法参数
                     * */
                    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                        Object invoke = method.invoke(userServicesImpl, objects);
                        return invoke;
                    }
                }
        );
       //代理对象调用方法
        userService.select();
 
    }

2.Cglib动态代理

Cglig动态是第三方提供的技术，需要导入jar包，并且可以是基于类继承，也可以是基于接口实现。

使用：先创建接口或类，然后创建被代理的对象类（继承或实现）。


    cglib
    cglib
    3.3.0

    @Test//2.为类创建代理对象，实现目标方法的功能增强（基于接口实现）
    public void test04(){
        //创建目标对象（被代理对象）
        UserServicesImpl userServicesImpl = new UserServicesImpl();
        Enhancer enhancer = new Enhancer();
        enhancer.setInterfaces(UserServicesImpl.class.getInterfaces());
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("前置 增强");
                //调用 目标方法
                Object invoke = method.invoke(userServicesImpl, objects);
                System.out.println("后置 增强");
                return invoke;
            }
        });
     //获取代理对象并调用方法
        UserService userService = (UserService) enhancer.create();
        userService.select();
    }



 @Test// 3.为类创建代理对象，实现目标方法的功能增强（基于继承实现）
    public void test05(){
        Enhancer enhancer = new Enhancer();//增强器
        enhancer.setSuperclass(Aaa.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("前置 增强");
                Object invoke = methodProxy.invokeSuper(o, objects);
                System.out.println("后置 增强");
                return invoke;
            }
        });
  //获取代理对象调用方法
     UserServicesImpl2 userServices = (UserServicesImpl2) enhancer.create();
     userServices.querry(1,2);
 
    }
}

3.总结

JDK动态代理机制是委托机制，只能对实现了接口的类生成代理，底层通过反射机制实现。（重点）

CGLIB动态代理机制是接口或继承机制，针对类生成代理，被代理类和代理类是继承关系，底层通过字节码处理框架asm，修改字节码生成子类

七.AOP

1. SpringAOP介绍(常见面试题)

面向切面编程是对面向对象编程的补充。 AOP 中模块化的单位是切面。

AOP中的专业术语：

Aspect：切面。为方法添加增强功能的过程。

join point：切入点。就是被代理的方法，也叫目标方法。

Advice：通知。就是增强内容。前置、后置、环绕、异常等通知。

Pointcut：切点。就是表达式，通过切点表达式可以找到目标方法（join point）。

Weaving：织入。织入就是把通知添加到切入点的过程。

AOP Proxy：代理。Spring支持JDK动态代理和cglib动态代理两种方式，可以通过proxy- target- class=true把默认的JDK动态代理修改为Cglib动态代理。

2. 实现AOP的两种方式

1.实现AOP需要引入依赖：



    org.aspectj
    aspectjweaver
    1.9.9.1


    aopalliance
    aopalliance
    1.0

2.实现AOP的两种方式：

Schema-based：所有的通知都需要实现特定类型的接口实现通知。

在Schema-based方式中通知的分类（面试题）：

前置通知，通知需要实现MethodBeforeAdvice接口。

后置通知，通知需要实现AfterReturningAdvice接口。

环绕通知，通知需要实现MethodInterceptor接口。

异常通知，通知需要实现ThrowsAdvice接口。

AspectJ：可以使用普通Java类结合特定的配置实现通知。

在AspectJ方式中通知的分类（面试题）：

前置通知：before。

后置通知：after。

after是否出现异常都执行的后置通知。

after-returning切入点不出现异常时才执行的后置通知。

环绕通知：around。

异常通知：after-throwing。

Schema-based和Aspectj的区别：

Schema-based：基于接口实现的。 AspectJ方式：是基于配置实现的。

Schame-based是运行时增强，AspectJ是编译时增强。

切面比较多时，最好选择AspectJ方式，因为AspectJ方式要快很多。

3.注解方式实现AOP

 
    
    
    autoproxy expose-proxy="true"/>

注意：

配置Spring容器注解扫描的路径。

配置AOP注解生效。

@Component	相当于配置文件的bean标签，将某个类的对象扫描到Spring容器中。
@Aspect	声明该类为通知类。结合@Component在通知类上使用。
@pointcut	声明切点，方法上使用。
@Before	声明方法为前置通知方法。
@After	声明方法为后置通知方法。
@Around	声明方法为环绕通知方法。
@AfterThrowing	声明方法为异常通知方法。

AOP工作流程：
1.通过切点表达式获取切入点（目标对象和目标方法）
2.为目标对象创建代理对象
3.在代理对象中织入通知，执行的目标方法

八.Sping声明式事务

声明式事务是基于AOP实现的。把开启事务的代码放在前置通知中，把事务回滚和事务提交的代码放在了后置通知中。

1.配置声明式事务

需要在配置文件中引入xmlns:tx命名空间。

2.注解配置声明式事务（主要使用）

Spring 注解配置事务时，只需要在需要有事务管理的方法上添加@Transactional注解。

必须保证配置注解的方法所在的类已经放入到Spring容器中。

配置注解扫描

开启事务注解的支持

必须配置事务管理器类

@Transactional的使用

@Transactional用在类上，整个类中方法都生效。

@Transactional用在方法上，该方法生效。用在方法上优先级更高。

3.声明式事务四个基础属性

标签有下面属性的配置，@Transaction注解也支持部分属性（如果有则含义相同，如果没有则表示在注解中不需要配置）。

1. name属性
配置哪些方法需要有事务控制，支持*通配符。

2. readonly属性
是否为只读事务，有true和false两种。

3. rollback-for属性
异常类型全限定路径，表示出现什么类型的异常进行数据回滚。默认运行时异常及子类异常回滚，检查时异常不回滚。

4. no-rollback-for属性
异常类型全限定路径，当出现什么异常的时候不进行数据回滚。

5. timeout属性
执行超过了设置的超时时间，回滚操作。（超时抛出异常）

4.事务传播行为（面试题）

4.1.介绍

事务传播行为：当出现service方法调用另一个service方法时（这些方法都被声明式事务管理）这些方法如何进行事务管理。

可以通过进行配置tx:method或@Transactional中的propagation属性来进行传播行为的设置。

@Transactional(propagation = Propagation.MANDATORY)

默认情况下都认为每个方法都是没有事务的（事务自动提交）。

整个调用最终都是在调用者里面统一提交回滚。

在声明式事务中，如果是同一个类的多个方法相互调用，属于同一个事务。

因为声明式事务是基于AOP实现的，AOP是基于动态代理实现的，为同一个对象创建一个代理对象，所以实现出来的效果只有对第一个调用的方法添加上了声明式事务管理，其他方法都是普通的方法调用。

4.2 propagation属性的可选值

Propagation.REQUIRED（默认）	当前有事务，使用当前事务。当前没有事务，开启新的事务。
Propagation.NEVER	必须在非事务状态下执行。没有事务，正常运行。有事务，抛出异常。
Propagation.NESTED	必须在事务状态下执行。没有事务，创建事务。有事务，创建嵌套事务。
Propagation.REQUIRES_NEW	没有事务，创建事务。有事务，挂起当前事务，创建新的事务。最后统一操作。
SUPPORTS	没有事务，非事务执行。有事务，使用当前事务。
Propagation.NOT_SUPPORTED	非事务下执行。有事务，挂起事务，以非事务执行，执行后，恢复挂起的事务。
propagation = Propagation.MANDATORY	事务下执行。没有事务，抛出异常。

九、Bean的生命周期（非常重要）

Spring中Bean的生命周期就是指Bean从初始化到销毁的过程。Bean最简单的实现就是直接使用标签定义这个Bean。

Bean生命周期流程：

编写bean的定义信息（xml，注解）。

通过BeanDefinitionReader 读取bean的定义信息。

解析出bean的定义信息。

可以通过BeanFactoryPostProcessor接口实现类，操作bean的定义信息。

实例化bean对象。

属性注入。

可以使用相关的Aware接口，获取bean的相关信息，容器信息...。

可以使用BeanPostProcessor接口中before方法操作对象。

可以使用init-method调用自定义的初始化方法。

可以使用BeanPostProcessor接口中after方法操作对象。

存储到单例池（一级缓存中）。

二、Sping MVC

一. Spring MVC介绍

Spring MVC本质为Spring 框架的一个扩展，属于Spring Framework的二级子项目。

Spring MVC是基于Front设计模式。

Spring MVC中有前端入口DispatcherServlet，里面编写了请求分发功能。

EmpController在Spring MVC称为控制器类（Handler），里面的方法称为：控制单元（HandlerMethod）。

MVC三层中都有自己的功能。例如：

M：在模型层包含：数据校验。

V：在视图层包含：国际化、标签库。

C：在控制层包含的功能就更多了：转发重定向、参数、拦截器、作用域等。

Spring中的父子容器问题：

二.Spring MVC环境搭建

导入依赖：

 
        
            org.springframework
            spring-webmvc
            5.3.16

配置springMVC.xml：

编写web.xml内容：

  
        springmvc
        org.springframework.web.servlet.DispatcherServlet
        
            
            contextConfigLocation
			
            classpath:springmvc.xml
        
        
        
        1
    
    
        springmvc
        
        /

创建控制器类：

@Controller// 放入到Spring MVC容器中
public class FirstController {
    /*
     * 官方标准写法：
     *      返回值是ModelAndView，对象中存储跳转资源路径及作用域值
     */
    // 当前方法的映射路径
    @RequestMapping("/first")
    public ModelAndView test1(){
        ModelAndView modelAndView = new ModelAndView("first.jsp");
        return modelAndView;
    }
    /*
     * 简化写法（平时使用的方式）
     *      返回值是String，表示跳转的资源路径
     */
    @RequestMapping("/first2")
    public String test2(){
        return "first.jsp";
    }
}

三.@RequestMapping注解

1.使用

@RequestMapping注解可以写在控制器类上，也可以写在控制单元方法上。

如果写在类上，表示当前类所有控制单元的映射路径，都以指定路径开头。

如果写在方法上，表示当前方法的映射路径。

2.注解的属性

1.path：映射的路径。
映射一个访问路径：path = {"aa"} 省略{} path = "aa"
映射多个访问路径：path = {"aa,bb"}。
2.value：和path作用相同，只有一个value属性时，value可以省略。
3.name：添加描述信息。
4.method：允许的请求方式。
RequestMethod.POST
RequestMethod.GET
...
简化：
@GetMapping 为 @RequestMapping(method = RequestMethod.GET)
@PostMapping 为 @RequestMapping(method = RequestMethod.POST)
...
5.params：指定请求中必须携带的请求参数。
6.headers：指定请求中必须携带的请求头。

7.consumes：表示处理请求内容(Content-Type)的类型。
8.produces：配合@ResponseBody注解使用，指定响应内容的类型。单独使用没有意义。

四.转发和重定向（重要）

在Spring MVC框架中，默认情况下都使用转发进行寻找资源。

在资源路径前面添加 forward: , 表示转发。

在资源路径前面添加 redirect: ，表示重定向。

五.静态资源放行

六.控制单元的参数（接收请求参数）


@Controller
@RequestMapping("emp")
public class EmpController {
/* 解耦合方式：获取请求数据，springmvc封装好的 */
/*
* DispatcherServlet 会接收请求数据，可以将请求数据进行相关处理，然后传递给控制单元。
* */

    //1、接收普通参数
        //建议：尽量使用封装类型，请求参数中没有携带该参数，自动赋值为null
        //@RequestParam()：请求参数中的名字 和 接收参数名不一致时，使用该注解指定为请求参数名的名字
    @RequestMapping("a1")
    public String a1(@RequestParam("name") String uname, Integer age){
        System.out.println(uname);
        System.out.println(age);
        return "/index.jsp";
    }

    //2、使用JavaBean对象接收请求参数
        //注意：即使请求参数中没有Emp的属性，创建emp对象，传递到控制单元中
        //      使用JavaBean接收请求参数需要依赖于set方法
    @RequestMapping("a2")
    public String a2(Emp emp){
        System.out.println(emp);
        return "/index.jsp";
    }

    @RequestMapping("a3")
    public String a3(Emp emp, String name, String age){
        System.out.println(emp);
        System.out.println(name);
        System.out.println(age);
        return "/index.jsp";
    }

    //3、接收多个同名参数
        //数组：请求参数名和控制单元参数名相同即可直接接收
        //集合（List集合为例）：必须通过@RequestParam执行请求参数名
                           //  如果为JavaBean中的属性为List集合接收同名多个属性，不需要进行额外处理。
    @RequestMapping("a4")
    public String a4(String[] strs){
        System.out.println(Arrays.toString(strs));
        return "/index.jsp";
    }

    @RequestMapping("a5")
    public String a5(@RequestParam("strs") List strs){
        System.out.println(strs);
        return "/index.jsp";
    }

    @RequestMapping("a6")
    public String a6(Emp emp){
        System.out.println(emp);
        return "/index.jsp";
    }

    @RequestMapping("a7")
    //注意：默认支持 yyyy/MM/dd 的日期格式
    //手动指定接收的日期格式（@DateTimeFormat），一定手动指定了接收的日期格式，默认的日期格式不再生效
    public String a7(@DateTimeFormat(pattern = "yyyy-MM-dd") Date bir){
        System.out.println(bir);
        return "/index.jsp";
    }

    @RequestMapping("a8")
    public String a8(Emp emp){
        System.out.println(emp);
        return "/index.jsp";
    }

    /* 接收请求头中的数据 */
    @RequestMapping("a9")
    public String a9(@RequestHeader String accept){
        System.out.println(accept);
        return "/index.jsp";
    }


    @RequestMapping("a10")
    public String a10(@RequestHeader(value = "Accept-Language") String str){
        System.out.println(str);
        return "/index.jsp";
    }

    /* 向作用域对象中存值（request作用域） */
    //方式一：
    @RequestMapping("a11")
    public ModelAndView a11(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/index.jsp");
        modelAndView.addObject("uname", "zs");
        return modelAndView;
    }

    //方式二：
    @RequestMapping("a12")
    public String a12(Map map){

        map.put("uname", "lsssss");

        return "/index.jsp";
    }

    //方式三：
    @RequestMapping("a13")
    public String a13(Model model){

        model.addAttribute("uname", "wwwwww");

        return "/index.jsp";
    }
}

七.@ResponseBody和@RequestBody注解

1.@ResponseBody

@ResponseBody：控制单元添加了该注解，不会执行视图解析器，将控制单元的返回值放入到响应流直接响应回到客户端。

使用：

        默认：

                1.控制单元只能返回String类型的数据。返回其他数据类型出现406状态码。

                2.配合@RequestMapping(produces = "text/plain;charset=utf-8")设置响应内容类型及编码格式。

        引入了Jackson的依赖：

                1.控制单元可以返回，JavaBean，数组[JavaBean], List, Map, List 等类型数据。

2.springmvc默认使用jack将控制单元的返回值变为json格式的字符串，设置响应内容类型为application/json;charset=utf-8。

@RestController注解：效果和控制器中所有的方法都包含@ResponseBody注解一样。

2.@RequestBody注解

将格式为 json ，xml 的客户端请求参数转换为 javabean。需要引入相依赖（Jackson）。

$.ajax({
    url:"testContentType",
    contentType:"application/json",// 修改请求内容类型为JSON
    data:'{"id":1,"name":"张三"}',// json格式传多个数据必须有单引号，没有单引号无效
    type:"post",// 不能是GET类型请求
    success:function (data) {
        console.log(data);
    },
    dataType:"json"
});

@RequestMapping("/testContentType")
@ResponseBody
public People testContentType(@RequestBody People peo) {
    System.out.println(peo);
    return peo;
}

八.Spring MVC文件上传和下载

1. 文件上传