SSM框架的介绍

小咪咪 2022-12-09 04:51 246阅读 0赞

## Spring ##

方便解耦,简化开发(Spring就是一个大工厂,可以将所有对象创建和依赖关系维护交给Spring管理)  
AOP 编程的支持,Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能  
声明式事务的支持,只需要通过配置就可以完成对事务的管理,而无需手动编程  
方便程序测试,Spring对junit4支持,可以通过注解方便测试Spring程序  
方便继承各种优秀框架,Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(Struts Hibernate Mybatis 等等)的直接支持  
降低JavaEE API的使用难度,Spring对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低  
整个项目中装配Bean的大工厂，在配置文件中可以指定使用特定的参数去调用实体类的构造方法来实例化对象，有两个核心分别是IOC(控制反转)和AOP(面向切面编程)  
**IOC控制反转，简单说就是讲new关键字创建对象的权利交给Spring框架来管理，开发者只关注业务逻辑处理**  
AOP面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术，利用AOP可以对业务逻辑的各个部分进行隔离，降低业务逻辑之间的耦合度，提高代码的可重用性，同时提高了开发的效率，事务管理、日志文件打印通常用到AOP  
**需要的jar包：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70_pic_center]  
最后需要commons-logging  
maven中pom.xml:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70]

Hello类：

public class Hello {
    	  private String name;
    	  public void setName(String name) {
    		  this.name=name;
    	  }
    	  public void show() {
    		  System.out.println("hello"+name);
    	  }
    }

测试类：

public class Test {
    		public static void main(String[] args) {
    			//解析beans.xml文件生成管理相应的bean对象
    			ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
    		
    		Hello hello = (Hello)context.getBean("hello");
    		hello.show();
    		}
    }

用maven是舒服,idea中项目结构：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 1]

还有个Beans.xml文件：

Hello对象是由spring容器创建。  
Hello对象属性是由spring容器来设置  
这个过程就叫控制反转：  
控制：是谁来控制对象的创建；传统的应用程序对象的创建是由程序本身控制的。使用spring后，是由spring来创建对象  
反转：值程序本身不去创建对象，而变为被动接受的对象  
总结：以前对象是由程序本身来创建，使用spring后，程序变为被动接受spring创建好的对象。控制反转—依赖注入  
**使用ioc来创建对象的三种方式**  
1.使用无参的构造方法来创建

private String name;
    	  public Hello() {
    		  System.out.println("无参构造创建对象");
    	  }
    	  public void setName(String name) {
    		  this.name=name;
    	  }
    	  public void show() {
    		  System.out.println("hello"+name);
    	  }

Beans.xml文件  
**别名：**

**bean的配置：**  
id:bean的唯一标识符，也就是我们对象名  
class：bean对象所对应的限定名（包名+类名）  
name:别名，可以取多个别名  
**import**  
将多个配置文件，导入合并为一个总文件（applicationContext.xml），最后使用的时候也就用这个总文件

2.通过有参构造方法来创建对象：

public class Hello {
    	  private String name;
    	  public Hello(String name) {
    		  this.name =name;
    		  System.out.println("有参构造创建对象");
    	  }
    	
    	  public void show() {
    		  System.out.println("hello="+name);
    	  }
    }

Beans.xml文件

**index指构造方法参数下标从0开始  
name指的是构造方法的参数名称  
type通过参数类型设置**  
3.通过工厂方法来创建对象  
静态工厂：

public class HelloFactory {
    	public static Hello newInstance(String name) {
    		return new Hello(name);
    		
    	}
    }

Beans.xml文件

动态工厂：

public class HelloDyFactory {
    	public Hello newInstance(String name) {
    		return new Hello(name);
    		
    	}
    }

Beans.xml文件：

**配置文件**  
id是bean的标识符 要唯一，如果没有配置id name默认标识符，都有id name 那么name是别名，name可以设置多个别名 分隔符可以使空格 逗号 分号

<alias name="" alias=""/>
    class是bean 的全限定名=包名+类名
    没有配置id和name，那么可以根据applicationContext.getBean(Class)获取对象
    导入其他资源 import

**依赖注入（DI）**  
依赖：指的是Bean对象的创建依赖于容器Bean对象的依赖资源  
注入：指的Bean对象所依赖的资源，由容器来设置和装配  
1.构造器注入  
2.set注入

public class ChinaGirlFriend {
    
        private String language;
    
        public ChinaGirlFriend(){
    
        }
    
        public ChinaGirlFriend(String language){
            this.language=language;
    
        }
        public String speak(){
            return language;
        }
    
        public void setLanguage(String language) {
            this.language = language;
        }
    }

public class DataType {
        private String s1;//特殊字符
        private String s2;//特殊字符
        private User innerBean;//内部类
        private List<String> list;
        private String[] array;
        private Set<String> set;
        private Map<String,String> map;
        private Properties properties;
        private String emptyValue;//注入空字符串
        private String nullValue = "init null";//注入null值
    
        public void setS1(String s1) {
            this.s1 = s1;
        }
    
        public void setS2(String s2) {
            this.s2 = s2;
        }
    
        public void setInnerBean(User innerBean) {
            this.innerBean = innerBean;
        }
    
        public void setList(List<String> list) {
            this.list = list;
        }
    
        public void setArray(String[] array) {
            this.array = array;
        }
    
        public void setSet(Set<String> set) {
            this.set = set;
        }
    
        public void setMap(Map<String, String> map) {
            this.map = map;
        }
    
        public void setProperties(Properties properties) {
            this.properties = properties;
        }
    
        public void setEmptyValue(String emptyValue) {
            this.emptyValue = emptyValue;
        }
    
        public void setNullValue(String nullValue) {
            this.nullValue = nullValue;
        }
    
        public void printValue(){
            System.out.println("特殊字符串1"+this.s1);
            System.out.println("特殊字符串2"+this.s2);
            System.out.println("内部类"+this.innerBean.getUsername());
            System.out.println("list属性"+this.list);
            System.out.println("数组属性"+this.array);
            System.out.println("set属性"+this.set);
            System.out.println("map属性"+this.map);
            System.out.println("properties属性"+this.properties);
            System.out.println("注入空字符串"+this.emptyValue);
            System.out.println("注入null值"+this.nullValue);
        }
    }

Beans.xml文件配置：  
依次是数组注入、List注入、set注入、Map注入、null注入、Properities注入

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:p="http://www.springframework.org/schema/p"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
              http://www.springframework.org/schema/context
              https://www.springframework.org/schema/context/spring-context.xsd
               http://www.springframework.org/schema/aop
                 https://www.springframework.org/schema/aop/spring-aop.xsd">
    
        <context:annotation-config/>
        <context:component-scan base-package="com.ddb.spring.auto"/>
    
        
        <bean class="com.ddb.spring.set.ChinaGirlFriend" id="chinaGirlFriend2">
            <property name="language" value="中文2"></property>
        </bean>
    
        
        <bean class="com.ddb.spring.set.ChinaGirlFriend" id="chinaGirlFriend">
            <constructor-arg index="0" value="中文"> </constructor-arg>
        </bean>
    
        
        <bean class="com.ddb.spring.set.ChinaGirlFriend" id="chinaGirlFriend3" p:language="中文3"></bean>
    
        <bean id="dataType" class="com.ddb.spring.set.DataType">
            
            <property name="s1">
                <value><![CDATA[EP&G]]></value>
            </property>
            
            <property name="s2">
                <value>EP&G</value>
            </property>
    
            
            <property name="innerBean">
                <bean class="com.ddb.spring.type.User">
                    <property name="username" value="sunYun"/>
                </bean>
            </property>
    
            
            <property name="list">
                <list>
                    <value>兵乓球</value>
                    <value>羽毛球</value>
                    <value>篮球</value>
                    <value>足球</value>
                </list>
    
            </property>
    
            
            <property name="array">
                <array>
                    <value>十元</value>
                    <value>二十元</value>
                    <value>一百元</value>
                </array>
            </property>
    
            
            <property name="set">
                <set>
                    <value>王一博</value>
                    <value>杨洋</value>
                    <value>王俊凯</value>
                </set>
    
            </property>
    
            
            <property name="map">
                <map>
                    <entry key="tableTennis" value="兵乓球"/>
                    <entry value="羽毛球" key="badminton"/>
                    <entry key="football" value="足球"/>
                    <entry value="篮球" key="basketball"/>
                </map>
            </property>
    
            
            <property name="properties">
                <props>
                    <prop key="学号">8399310</prop>
                    <prop key="性别">男</prop>
                    <prop key="姓名">douDou</prop>
                </props>
            </property>
    
            
            <property name="emptyValue">
                <value></value>
            </property>
            
            <property name="nullValue">
                <null></null>
            </property>
    
        </bean>
    
    
    </beans>

我们可以使用p命令和c命令空间进行注入，需要导入xml约束

xmlns:p="http://www.springframework.org/schema/p"
           xmlns:c="http://www.springframework.org/schema/c"
     
        <bean id="hello2" class="com.qj.pojo.Hello" p:name="Spring"/>

<bean id="hello3" class="com.qj.pojo.Hello" c:name="Spring1"/>

**Bean的作用域**  
在spring中，那些组成应用程序的主体及Spring Ioc容器所管理的对象，被称为bean.简单说bean就是由Ioc容器初始化。装配及管理的对象

默认是单例模式（scope=“singleton”）

@Test
        public  void test2(){
            ApplicationContext applicationContext =
                    new ClassPathXmlApplicationContext("bean.xml");
            Hello hello = (Hello) applicationContext.getBean("hello3",Hello.class);
            Hello hello1 =(Hello) applicationContext.getBean("hello3",Hello.class);
            System.out.println(hello==hello1);//true
    
        }

原型模式，每次从容器取get的时候，都会产生一个新对象scope=“prototype”

其余request、session、application、这些在web开发中使用到,纯Java后台用不到.  
3.request  
当一个bean的作用域为request，表示再一次HTTP请求中，一个bean定义一个实例；**即每个http请求都会有各自的bean实例**。他们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效  
4.session  
同一个HTTP Session共享一个Bean，不同Session使用不同Bean,仅适用于webApplicationContext环境。当HTTPSession最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉  
**自动装配**  
1、在xml中显示定义

2、autowire=""  
**byName自动装配**  
byname:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid

**byType自动装配**  
会自动在容器上下文查找，和自己对应属性类型相同的bean

<bean class="com.qj.pojo.Cat"></bean>
        <bean  class="com.qj.pojo.Dog"></bean>
    
        <bean id="people" class="com.qj.pojo.People" autowire="byType">
            <property name="name" value="豆豆"></property>
        </bean>

**注解自动装配**  
导入约束:

xmlns:context="http://www.springframework.org/schema/context"

配置注解的支持

<context:annotation-config/>

**配置文件如下:**

@Autowired  
直接在属性上使用即可，也可以在set方法中使用，使用Autowired我们可以不用编写set方法了，前提配置ok(自动装配的属性在ioc容器中存在)  
@Autowired  
@Qualifier()两个一起使用去找到要装配的属性(指定注入Bean的名称)

@Autowired
        @Qualifier(value = "dog1")
        private Dog dog;
        @Autowired
        @Qualifier(value = "cat2")
        private Cat cat;

@Nullable 字段标记了这个注解，说明这个字段可以为null  
@Resource

@Resource(name = "dog1")
        private Dog dog;

@Resource 和@Autowired的区别  
都是自动装配，都可以放在属性字段上  
@Autowired通过byType的方式实现，而且必须要求这个对象存在  
@Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现，如果两个都找不到的情况就报错  
**使用注解开发（重要！）**  
在spring4之后使用注解开发，必须保证aop的包导入了，使用需要导入context约束，增加注解的支持

@Component
    //<bean id="user " class="com.qj.pojo.user">
    public class People {
        @Value("spring")
        //<property name="name" value="spring"/>
        public void setName(String name) {
            this.name = name;
        }
        }

跟@Component有几个衍生的注解，差不多用法  
dao --------@Repository  
sercice------@Service  
controller----@Controller  
都代表将某个类注册到Spring中，装配bean

**配置类**  
配置类：

package com.doupijiang.config;
    
    import com.doupijiang.pojo.User;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    
    @Configuration
    @ComponentScan("com.doupijiang.pojo")
    public class UserConfig {
        //这个方法名就相当于之前配置文件bean的id
        //返回值相当于bean标签的class属性
        @Bean
        public User getUserName(){
            return new User();
        }
    }

package com.doupijiang.pojo;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    @Component
    public class User {
    
        private String name;
        @Value("douPiJiang")
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void show(){
            System.out.println("java配置类实现"+getName());
        }
    }

@Test
        public void test(){
            ApplicationContext applicationContext = new AnnotationConfigApplicationContext(UserConfig.class);
            User user =(User) applicationContext.getBean("getUserName");
            user.show();
    
        }

**aop**  
这个时候增加一个jar包:

<dependencies>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

1、方式一：原生spring api接口  
**动态代理代理的是接口**  
UserService接口：

public interface UserService {
        void add();
        void delete();
        void update();
        void select();
    }

UserServiceImp实现类:

public class UserServiceImp implements UserService{
        public void add() {
            System.out.println("进行了add方法");
        }
    
        public void delete() {
            System.out.println("进行了delete方法");
        }
    
        public void update() {
            System.out.println("进行了update方法");
        }
    
        public void select() {
            System.out.println("进行了select方法");
        }
    }

import org.springframework.aop.MethodBeforeAdvice;
    
    import java.lang.reflect.Method;
    
    public class BeforeLog implements MethodBeforeAdvice {
        /**
         *
         * @param:参数method要执行的目标对象的方法
         * @param:参数object
         * @param:参数o执行的对象
         * @throws Throwable
         */
        public void before(Method method, Object[] objects, Object o) throws Throwable {
            System.out.println("方法之前"+method.getName()+"被执行了");
        }
    }

import org.springframework.aop.AfterReturningAdvice;
    
    import java.lang.reflect.Method;
    
    public class AfterLog implements AfterReturningAdvice {
        /**
         *
         * @param o:返回值
         * @param method:执行对象的方法名
         * @param objects:参数
         * @param o1:执行的对象
         * @throws Throwable
         */
        public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
            System.out.println("方法之后"+method.getName()+"执行了");
        }
    }

application.xml文件

把上面两个日志类切入到该业务的方法中  
测试：

import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class TestAop {
        @Test
        public void test(){
            ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
            UserService userService =(UserService) context.getBean("userServiceImp");
            userService.add();
        }
    }
    方法之前add被执行了
    进行了add方法
    方法之后add执行了

2、**自定义实现aop(主要是切面定义)**  
自己写个类

public class SelfAop {
        public void before(){
            System.out.println("执行方法前");
        }
    
        public  void after(){
            System.out.println("执行方法后");
        }
    }

这样配置了：

<bean id="self" class="com.qj.log.SelfAop"/>
        <aop:config>
           
           
            <aop:aspect ref="self">
                
                <aop:pointcut id="pointcut" expression="execution(* com.qj.service.UserServiceImp.*(..))"/>
                <aop:before method="before" pointcut-ref="pointcut"/>
                <aop:after method="after" pointcut-ref="pointcut"/>
            </aop:aspect>
        </aop:config>

测试:

@Test
        public void test(){
            ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
            UserService userService =(UserService) context.getBean("userServiceImp");
            userService.delete();
        }
    执行方法前
    进行了delete方法
    执行方法后

3、注解方式aop  
一次导包导约束  
application.xml的配置：

<context:component-scan base-package="com.qj.service" />
    
        
        <aop:aspectj-autoproxy proxy-target-class="true"/>

自动代理方式:  
proxy-target-class=“true” - 使用cglib动态代理  
proxy-target-class=“false” - 使用jdk动态代理  
默认jdk，spring是使用cglib的，需要改为true.false也可以

package com.qj.service;
    
    
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    @Component("userService")
    public class UserService {
    
        //配置切点
        @Pointcut("execution(* com.qj.service.UserService.getUsers())")
        public void getUsers(){
            System.out.println("查询出所有的学生");
        }
    }

@Component
    @Aspect
    public class SelfAop {
        //前置
        @Before("com.qj.service.UserService.getUsers()")
        public  void before(){
            System.out.println("前置------查询方法之前");
        }
    
        //后置
        @After("com.qj.service.UserService.getUsers()")
        public  void after(){
            System.out.println("后置-------查询方法之后");
        }
    }

环绕注解写法加上：

//环绕
        @Around("com.qj.service.UserService.getUsers()")
        public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
            System.out.println("环绕前");
            Object object=proceedingJoinPoint.proceed();
            System.out.println("环绕后");
            return object;
        }

我们测试下：

package com.qj.test;
    
    import com.qj.service.UserService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class TestAopAnno {
        @Test()
        public  void test(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
             UserService userService =(UserService) applicationContext.getBean("userService");
             userService.getUsers();
        }
    }
    前置------查询方法之前
    查询出所有的学生
    后置-------查询方法之后

## SpringMVC ##

**SpringMVC 常用注解**  
1、@RequestMapping 路径映射  
(1） value， method；  
value： 指定请求的实际地址，指定的地址可以是URI Template 模式（后面将会说明）；  
method： 指定请求的method类型， GET、POST、PUT、DELETE等；  
（2）consumes，produces  
consumes： 指定处理请求的提交内容类型（Content-Type），例如application/json, text/html;  
produces: 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；  
（3）params，headers  
params： 指定request中必须包含某些参数值是，才让该方法处理。  
headers： 指定request中必须包含某些指定的header值，才能让该方法处理请求。  
value 指定请求路径  
method 指定请求类型

@RequestMapping(value = "/detail"，params="password=68163")

headers 指定request 中必须包含指定的header 才能让该方法执行

@RequestMapping(value = "/detail",headers="Accept=application/json")

**后台获取前端传来的json数据方式**  
1、以RequestParam接收  
前端传来的是json数据不多时

@RequestMapping(value = "/update")
    @ResponseBody
    public String updateAttr(@RequestParam ("id") int id) {
        int res=accomodationService.deleteData(id);
        return "success";
    }

2、以实体类方式接收  
前端传来的是一个json对象时：\{\[id，name\]\},可以用实体类直接进行自动绑定

@ResponseBody
        public String addObj(@RequestBody Account account) {
         
            return "success";
        }

3、以Map接收  
前端传来的是一个json对象时：\{\[id，name\]\},可以用Map来获取

@ResponseBody
    public String updateAttr(@RequestBody Map<String, String> map) {
        if(map.containsKey("id"){
            Integer id = Integer.parseInt(map.get("id"));
        }
        if(map.containsKey("name"){
            String objname = map.get("name").toString();
        }

4、以List接收  
当前端传来这样一个json数组：\[\{id,name\},\{id,name\},\{id,name\},…\]时，用List接收

@ResponseBody
    public String updateAttr(@RequestBody List<Account> list) {
        for(Account account:list){
            System.out.println(account.toString());
        }
        return "success";
    }

consumes 指定请求的内容类型 例如：Application/json ， text/html

@RequestMapping(value = "/detail", consumes ="application/json")

Produces 指定返回的内容类型，仅当request 请求头中的类型包含该指定类型才能返回

@RequestMapping(value = "/detail", produces ="application/json")

@RequestHeader绑定请求报头的属性值  
请求头包含了若干个属性，服务器可据此获知客户端的信息，通过@RequestHeader即可将请求头中的属性值绑定到方法的入参中  
2、@RequestParam 获取请求参数  
用于将url 中的的参数，映射到方法的参数上。

@RequestMapping(value = "/login")
      public class loginController {
             @RequestMapping(value = "/detail")
             public String getName(@RequestParam String username) {
             //http://localhost:8080// login/detail？username=“张三” 则将张三赋值给username
                 return null;
             }
      }

@RequestParam 注解有三个参数：  
value required defaultValue  
(1)value ： 即url 路径中参数的名字  
(2)required ： 是否必须，默认为 true ，表示请求中一定要有相应的参数，否者会抛出异常。即：若上面代码中，url 路径中没有与方法同名的参数，将会抛出异常。  
(3)defaultValue ： 默认值，表示若请求中没有同名参数时的默认值，设置该参数时，自动将required设为false。  
注意：若url请求参数中没有对应的username 的参数，则会抛出异常,可以设置required 的值为false ，这样若url 请求中没有对应的参数，则会默认为null  
3、@PathVariable绑定URL 模板变量值

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <a href="${pageContext.request.contextPath}/show/1111">1111号</a>
        <a href="${pageContext.request.contextPath}/show/2222">2222号</a>
    </body>
    </html>

@Controller
    public class RestfulController {
        @RequestMapping(method = RequestMethod.GET,value = "/show/{topicId}")
        public String getString(@PathVariable("topicId") String topicId){
            System.out.println("topicId:"+topicId);
            if(topicId.equals("1111")){
                System.out.println("这是1111号");
            }else if(topicId.equals("2222")){
                System.out.println("这是2222号");
            }
    
            return topicId;
        }
    }

4、@ModelAttribute用在方法上 、 用在方法参数列表上  
(1)应用于方法参数,参数可以在页面直接获取，相当于  
request.setAttribute() ，应用于方法参数时@ModelAttribute(“xx”),须关联到Object的数据类型  
，基本数据类型 如：int,String不起作用  
（2)应用于方法,将任何一个拥有返回值的方法标注上 @ModelAttribute，使  
其返回值将会进入到模型对象的属性列表中.

@ModelAttribute("items")//向模型对象中添加一个名为items的
    //属性  任何请求处理方法执行前调用
    public List<String> populateItems() {  
            List<String> lists = new ArrayList<String>();  
            lists.add("item1");  
            lists.add("item2");  
            return lists;  
    }  
    @RequestMapping(params = "method=listAllBoard")  
    public String listAllBoard(@ModelAttribute("currUser")User user, 
    ModelMap model) {  
            bbtForumService.getAllBoard();  
            //访问模型中的items属性  
            System.out.println("model.items:" + ((List<String>)
    model.get("items")).size());  
            return "listBoard";  
    }

5、@SessionAttributes 将值放到session 域中

@SessionAttributes("account1")
    public class UserController {
     @RequestMapping(value = "/user",method = RequestMethod.POST,
                produces = "text/html;charset=utf-8")
    	public String(Model model){
    	     //将此用户对象放在作用域
    		mv.addObject("account1",account1);
    		return "index";
    	}
    }

移除session

@RequestMapping(value = "/user",method = RequestMethod.POST,
                produces = "text/html;charset=utf-8")
                 public String logout(Model model, @ModelAttribute("account1")  Account account,SessionStatus status){
    		if(account!=null)
    			status.setComplete();
            return "home";
            
        }

6、@ResponsBody 与 @RequestBody 传输json 格式数据

@RequestMapping("/login/detail")
        @ResponseBody     // 返回json 格式数据
        public User getJsonUser(@RequestBody User user) {   // 接收json 格式数据
           return user;
      }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 2]

**执行原理**  
1、客户端发送请求  
2、**前端控制器DispatcherServlet**接受客户端请求  
3、找到**处理器映射HandlerMapping**解析请求对应的Handler（处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet）  
4、**HandlerAdapter**会根据Handler来调用**真正的处理器**（(Controller，也叫后端控制器)）处理请求，并处理相应的业务逻辑  
5、处理器返回一个模型视图**ModelAndView**  
6、视图解析器进行解析（DispatcherServlet将ModelAndView传给**ViewReslover视图解析器**，ViewReslover解析后返回具体View  
DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中））  
7、返回一个视图对象  
8、前端控制器DispatcherServlet渲染数据（Model），将得到视图对象返回给用户  
**SpringMVC 五大核心组件**  
　　 1.DispatcherServlet　　请求入口  
　　 2.HandlerMapping　　 请求派发,负责请求和控制器建立一一对应的关系  
　　 3.Controller　　　　　 处理器  
　　 4.ModelAndView　　　 封装模型信息和视图信息  
　　 5.ViewResolver　　　　视图处理器,定位页面  
**View Resolver**  
（1）负责将处理结果生成View视图  
（2）一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面  
（3）springmvc框架提供了很多的View视图类型，包括：jstlView、freemarkerView、pdfView等  
（4）View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户  
**是Spring框架的一个模块，是基于MVC的web框架，可以说是前后端数据传输的一个桥梁**  
view to controller:  
**数据绑定（请求参数的处理(重要)）:**  
**1、基本数据类型:**  
参数尽量使用包装类型:int ----------Interger

@RestController
    public class DataBindingController {
    
        @GetMapping("/itemList")
        public String getStringInfo(@RequestParam("num") Integer num){
            return "数字为:"+num;
        }
    }

http://localhost:8080/itemList?num=9

![在这里插入图片描述][20210208081637269.png]

util.Date比较特殊:

@DateTimeFormat(pattern = "yyyy-MM-dd") 
    Date date;

还有种自定义类转化器:

@InitBinder
        public void hello(WebDataBinder webDataBinder){
    
            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
            CustomDateEditor dateEditor = new CustomDateEditor(dateFormat,true);
    
           webDataBinder.registerCustomEditor(Date.class,dateEditor);
        }

一次配置就行，

或者这样写配置文件:

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="webBindingInitializer" ref="customBinder"></property> 
    </bean>
            
        <bean id="customBinder"
           class="org.springframework.web.bind.support.ConfigurableWebBindingInitializer">
           <property name="conversionService" ref="conversionService" />
        </bean>
        
        <bean id="conversionService"
           class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
           
           <property name="converters">
               <list>
                  <bean class=" com.qj.controller.converter.CustomDateConverter"/>
               </list>
           </property>
        </bean>

public class DateConvert implements Converter<String, Date> {
        @Override
        public Date convert(String s) {
            Date date =null;
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            try {
               date= simpleDateFormat.parse(s);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return  date;
        }
    }

数组：  
页面前台：

Controller方法中可以用String\[\]接收

@GetMapping("/array")
    public String deleteitem(String[] item_id)throws Exception{
        System.out.println(item_id);
    }

http://localhost:8080/itemList1?name=%E5%91%A8%E5%91%A8&name=qqq![在这里插入图片描述][20210208083335846.png]

@GetMapping("/itemList1")
        public String getArrayInfo(String[] name){
            StringBuilder stringBuilder = new StringBuilder();
            for(String n:name){
                stringBuilder.append(n);
            }
            return "数组："+stringBuilde.toString();
        }

**2、对象类型**:  
1、简单的pojo  
将pojo对象中的属性名于传递进来的属性名对应，如果传进来的参数名称和对象中的属性名称一致则将参数值设置在pojo对象中  
Item类：

public class Item{
    	private String name;
    	private String price;
    
    	自己提供setter/getter方法 和toString方法
    }

http://localhost:8080/itemList2?name=doudou&price=89

@GetMapping("itemList2")
        public String getPojoInfo(Item item){
    
            return "对象类型"+item;
        }

**注意**：请求的参数名称和pojo的属性名称一致，会自动将请求参数赋值给pojo的属性。  
（2）包装pojo（重要）

public class QueryVo {
        private Items items;
        自己提供setter/getter方法
    }

public String useraddsubmit(Model model,QueryVo queryVo)throws Exception{
        System.out.println(queryVo.getItems());
    }

这里Item类有个Account类(多层级对象数据绑定)

public class Item {
        private String name;
        private String price;
        private Account account;
        自己提供setter/getter/toString方法
    }

Account类

public class Account {
        private String name;
        private Integer age;
        自己提供setter/getter/toString方法
    }

http://localhost:8080/itemList3?name=d&price=4&account.name=pp&account.age=23

@GetMapping("itemList3")
        public String getVoInfo(Item item){
            return "包装对象:"+item.toString();
        }

![在这里插入图片描述][20210208085900625.png]  
同属性多对象数据绑定

![在这里插入图片描述][20210208090741175.png]

自己建立类的时候应该使得跟其他对象属性不一致或者对象属性区分开？（如何做？）

@GetMapping("itemList4")
        public String getDifferentInfo(Item item, Vo vo ){
            return "不同对象同属性:"+item+""+vo;
        }
    
        @InitBinder("item")
        public void initItem(WebDataBinder binder){
            binder.setFieldDefaultPrefix("item.");
        }
    
        @InitBinder("vo")
        public void initVo(WebDataBinder binder){
            binder.setFieldDefaultPrefix("vo.");
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 3]

**3、集合类型**:  
（1）list  
List中存放对象，并将定义的List放在包装类中，controller使用包装对象接收  
List中的对象：  
包装类中定义List对象，并添加get/set方法

public class QueryVo {
        private List<Item> itemList;//商品列表
        //get/set方法..
    }

页面定义如下：

上边的静态代码改为动态jsp代码如下：

<c:forEach items="${itemsList }" var="item" varStatus="s">
    <tr>
        <td><input type="text" name="itemsList[${s.index }].name" value="${item.name }"/></td>
        <td><input type="text" name="itemsList[${s.index }].price" value="${item.price }"/></td>
        .....
        .....
    </tr>
    </c:forEach>

Contrller方法定义

public String useraddsubmit(Model model,QueryVo queryVo)throws Exception{
        System.out.println(queryVo.getItemList());
    }

http://localhost:8080/itemList5?itemList\[0\].name=q&itemList\[3\].name=j

public class ItemList {
        private List<Item> itemList;
     自己提供setter/getter/toString方法
    }

@GetMapping("itemList5")
        public String getListInfo(ItemList itemList){
            return "集合List对象:"+itemList;
        }

(2)map  
在包装类中定义Map对象，并添加get/set方法，controller使用包装对象接收。  
包装类中定义Map对象如下

public class QueryVo {
        private Map<String, Object> itemInfo = new HashMap<String, Object>();
        //get/set方法..
    }

页面定义如下：

Contrller方法定义如下：

public String useraddsubmit(Model model,QueryVo queryVo)throws Exception{
        System.out.println(queryVo.getStudentinfo());
    }

public class ItemMap {
        private Map<String,Item> map;
        自己提供setter/getter/toString方法
    }

@GetMapping("itemList6")
        public String getMapInfo(ItemMap map){
            return "集合Map对象:"+map;
        }

**json格式的数据绑定：**

@GetMapping("itemList7")
        public String getJsonInfo(@RequestBody Item item){
            return "Json对象:"+item;
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 4]

![在这里插入图片描述][2021020809581646.png]

**springmvc中如何实现重定向?**  
转发(默认): return “index”;  
return “view/show”;  
重定向: return “redirect:/user/index”;  
Model:模型  
1、业务逻辑，2、保存数据的状态  
Controller:控制器  
1、取得数据2、调用业务3、转向指定的页面  
View:视图  
1、展示页面  
MVC框架要做哪些事情：  
1、将url映射到java类或者java类的方法  
2、封装用户提交的数据（?method=add）  
3、处理请求，调用相关的业务处理，封装相应的数据  
4、将响应的数据进行渲染，jsp,html等表示层  
学习它的好处：  
1、轻量级、简单易学  
2、高效，基于请求响应的MVC框架  
3、与Spring框架兼容性好，无缝结合  
4、约定大于配置  
5、**功能强大：REST风格、数据验证、格式化、本地化、主体等**  
6、简洁灵活  
怎么理解呢？  
相当于中心控制器。**以前每个请求都写一个servlet,现在DispatcherServlet的作用将请求分发到不同的处理器**  
使用springmvc必须配置的三大件：  
处理器映射器、处理器适配器、视图解析器  
**但是注解的时候，只需要视图解析器了**  
springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
    
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        
        <context:component-scan base-package="com.qj.controller"/>
     
        <mvc:annotation-driven/>
    
        
        <mvc:default-servlet-handler/>
        
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/jsp/" />
            <property name="suffix" value=".jsp"/>
        </bean>
    </beans>

InternalResourceViewResolver：支持JSP视图解析  
viewClass：JstlView表示JSP模板页面需要使用JSTL标签库，所以classpath中必须包含jstl的相关jar 包；  
prefix 和suffix：查找视图页面的前缀和后缀，最终视图的址为：  
前缀+逻辑视图名+后缀，逻辑视图名需要在controller中返回ModelAndView指定，比如逻辑视图名为hello，则最终返回的jsp视图地址 “WEB-INF/jsp/hello.jsp”  
web.xml

load-on-startup：表示servlet随服务启动；  
url-pattern：\*.action的请交给DispatcherServlet处理。  
contextConfigLocation：指定springmvc配置的加载位置，如果不指定则默认加载WEB-INF/\[DispatcherServlet 的Servlet 名字\]-servlet.xml。  
Servlet拦截方式  
1）拦截固定后缀的url，比如设置为 *.do、*.action， 例如：/user/add.action  
此方法最简单，不会导致静态资源（jpg,js,css）被拦截。  
2）拦截所有，设置为/，例如：/user/add /user/add.action  
此方法可以实现REST风格的url，很多互联网类型的应用使用这种方式。但是此方法会导致静态文件（jpg,js,css）**被拦截后不能正常显示。需要特殊处理**。  
3）拦截所有，设置为`/*`，此设置方法错误，因为请求到Action，当action转到jsp时再次被拦截，提示不能根据jsp路径mapping成功。  
测试一下：

@Controller
    public class HelloController {
        @RequestMapping("/h1")
        public String hello(Model model){
            //封装数据，通过参数model
            model.addAttribute("msg","Hello MVC Annoation");
            return  "test";//会被视图解析器处理
        }
    @RequestMapping("/h2")
        public String hello(Model model){
            //封装数据，通过参数model
            model.addAttribute("msg","Hello MVC Annoation2");
            return  "test";//会被视图解析器处理
        }
    }

避免了web.xml大量配置servlet,在这个类中可以请求了  
**这里讲解常用两种实现请求跳转：**  
1、实现controller接口  
2、使用@Controller注解（用的最多）  
代表这个类被Spring接管，被这个注解的类中的所有方法，如果返回值是string,并且有具体页面可以跳转，那么该会被视图解析器解析。  
**我们这两个请求都可以指向同一个视图，但是页面结果是不一样的，从这里可以看出视图是被复用的，而控制器与视图之间是弱耦合的**  
**注解映射技巧**  
GET和POST都可以  
@RequestMapping(method=\{RequestMethod.GET,RequestMethod.POST\})  
@RequestMapping("/h1");  
用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上  
（1）支持标准的url  
(2)Ant风格URL(即？和*和*`**`)等字符  
（3）带\{xxx\}占位符的url  
例如：  
/user/\*/creation  
匹配/user/aaa/creation、/user/vvv/creation  
/user/`**`/creation  
匹配/user/creation、/user/aaa/vvv/creation等URL  
/user/\{userId\}  
匹配user/123、user/avd等url  
/company/\{companyId\}/user/\{iserId\}/detail  
匹配/company/123/user/456/detail等的url

**请求方法细节处理**  
HttpServletRequest  
通过request对象获取请求信息  
HttpServletResponse  
通过response处理响应信息  
1、请求参数绑定  
2、请求方式限制  
3、请求转发和重定向  
4、数据模型赋值  
5、返回json数据  
6、cookie访问

**json数据的处理**

@Controller
    @RequestMapping("/login")
    public class LoginController {
    
        @Autowired
        private JokeService jokeService;
    
        @RequestMapping(value = "/joke",method = RequestMethod.GET,
                produces = {"application/json;charset=UTF-8"})
        @ResponseBody
        public String joke(){
            String sJoke=null;
            try{
                sJoke = jokeService.getJoke();
            }catch (Exception e){
                e.getMessage();
            }
    
            return sJoke;
    
        }
    }
    {"msg":"获取1条笑话","jokes":["某同学上课睡觉，老师见了火气很大，
    就叫他到黑板上解题，准备当众羞辱他一下。才站起来，
    老师就开始说啦：“成绩那么差，还敢上课睡觉，真不知羞耻
    ，就会睡觉！”结果此同学漂亮的把题解出来了，老师顿时有点下不来台
    。结果他自己走回座位，坐下淡淡的说：“我先睡一下，你待会
    还有不会的再问我。”"]}

**cookie的处理**

@Controller
    public class HelloMVC {
        @RequestMapping(value = "/hello")
        public String Hello(Model model,@CookieValue(value = "killPhone",required = false)Long phone){
            if(phone==null){
                
            }
            model.addAttribute("msg","helloMVC");
            return "test";
        }
    
    }

**Restful风格**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 5]

是一个资源定位及资源操作的风格。基于这个风格设计的软件更简洁，更有层次，更易于实现缓存等机制  
功能：  
1、资源：互联网所有的事物都可以被抽象为资源  
2、资源操作:使用post、delete、put、get、使用不同方法对资源进行操作  
3、分别对应添加、删除、修改、查询  
以前不同的参数实现不同的效果，方法单一，post和get  
现在restful操作资源：可以通过不同的请求方式来实现不同的效果，**请求地址一样，但是功能可以不同**  
举例：http://127.0.01/item/1 查询，GET  
http://127.0.01/item/ 新增，POST  
http://127.0.01/item/更新，PUT  
http://127.0.01/item/1 删除，DELETE  
之前问号带参（http://127.0.01/show?a=1&b=2）  
现在Resultful:http://127.0.01/show/show/1/2

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 6]  
**rest设计合理性一般不应该在url中出现动词**

@PostMapping("/show/{s1}/{s2}")
        public String show(@PathVariable int s1,@PathVariable String s2,Model model){
            String a = s1+s2;
    
            model.addAttribute("msg","字符串为:"+a);
    
            return "test";
        }
    
        @RequestMapping(value = "/show/{a}/{b}",method = RequestMethod.GET)
        public String show1(@PathVariable String a,@PathVariable int b, Model model){
            String r = a+b;
            model.addAttribute("msg","结果2为："+r);
            return "test";
        }

rest总结：  
1.每一个URI代表一种资源  
⒉客户端和服务器之间，传递这种资源的某种表现层  
3.客户端通过HTTP动词，对服务器端资源进行操作，实现“表现层状态转化”  
不配置视图解析器（springmvc.xml那段去掉），也可以完成请求转发

@Controller
    public class RequestResponse {    
    @GetMapping("/show/rs1/m1")
        public  String show(Model model){
            model.addAttribute("msg","请求转发");
            return "/WEB-INF/jsp/test.jsp";//请求转发
        }  @GetMapping("/show/rs2/m2")
        public String show2(Model model){
            model.addAttribute("msg","redirect");
            return "redirect:/index.jsp";
        }
        }

重定向，不需要视图解析器，本质就是重新请求一个新地方，只要注意路径问题  
**接受请求参数：**  
如果是对象的话，前端传递的参数名和对象名必须一致，否则就是null;  
如果是表单之类的参数提交的话，可以指明参数名@RequestParam(“password”),如果是其他名，后会保错，没声明参数，其他参数名会出现null;

@RequestMapping("/show")
    public class ParamsDemo {
    
        @GetMapping("/t1")
        public  String show(@RequestParam("username") String name){
            System.out.println(name);
            return "test";
        }
    }

model：几个方法适用于存储数据。简化了对于model对象的操作和理解  
modelmap:继承了LinkedMap。除了自身的一些方法，同样继承LinkedMap的方法  
modelview可以在存储的同时，可以进行设置返回的逻辑视图，进行控制层的跳转

**处理json乱码问题：**

<?xml version="1.0" encoding="UTF-8"?>
    
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        
        <context:component-scan base-package="com.qj.controller"/>
        <mvc:default-servlet-handler/>
    
        
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/jsp/" />
            <property name="suffix" value=".jsp"/>
        </bean>
    
    
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>
    </beans>

**处理Post中文乱码的问题：**  
在web.xml配置下过滤器：

<filter>
            <filter-name>encodingFilter</filter-name>
            <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
            <init-param>
                <param-name>encoding</param-name>
                <param-value>utf-8</param-value>
            </init-param>
        </filter>
        <filter-mapping>
            <filter-name>encodingFilter</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>

对于get请求中文参数出现乱码解决方法:  
修改tomcat配置文件添加编码与工程编码一致，如下：

另外一种方法对参数进行重新编码：

String userName new  
String(request.getParamter(“userName”).getBytes(“ISO8859-1”),“utf-8”)  
ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码  
**springmvc之ajax**  
前端通过ajax拿到后端的数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>异步加载数据</title>
    </head>
    <script src="${pageContext.request.contextPath}/lib/jquery-3.2.1.js">
    </script>
    <script>
        $(function(){
            $("#btn").click(function (){
                $.get("${pageContext.request.contextPath}/ajaxTest",function (data){
                    // console.log(data)
                    //js操作dom节点
                    let html="";
                    for(let i=0;i<data.length;i++){
                        html+="<tr>" +
                            "<td>"+data[i].age+"</td>"+
                            "<td>"+data[i].name+"</td>"+
                            "<td>"+data[i].hobby+"</td>"+
                            "</tr>"
                    }
                    $("#context").html(html);
                })
            })
        })
    </script>
    <body>
    <div>
        <table border="1px" width="20px" cellpadding="1px">
            <tr>
                <td>年龄</td>
                <td>姓名</td>
                <td>爱好</td>
            </tr>
            <tbody id="context">
    
            </tbody>
        </table>
        <input type="button" id="btn" value="ajax异步加载数据">
    </div>
    
    </body>
    </html>

后台数据供前端操作

@RestController
    public class testAjax {
        @RequestMapping("/ajaxTest")
        public  List<User> getData(){
            User user1 = new User(21,"豆豆4","篮球");
            User user2 = new User(22,"豆豆3","篮球");
            User user3 = new User(23,"豆豆2","篮球");
            User user4 = new User(24,"豆豆1","篮球");
            List<User> userList = new ArrayList<User>();
            userList.add(user1);
            userList.add(user2);
            userList.add(user3);
            userList.add(user4);
            return userList;
        }
    }

**拦截器**  
拦截器是AOP思想的具体应用  
（1）是SpringMVC框架自己的。只有使用了SpringMVC框架的工程才能使用  
（2）**拦截器只会拦截访问的控制器方法，如果访问的是是jsp、html、css、image、js是不会进行拦截的**  
拦截器的配置  
springmvc-servlet.xml

<mvc:interceptors>
           <mvc:interceptor>
               <mvc:mapping path="/user/**"/>
               <bean class="com.qj.controller.LoginInterceptor"/>
           </mvc:interceptor>
        </mvc:interceptors>

**文件上传**  
Servlet3.0规范已经提供方法来处理文件上传了，springmvc则提供了更简单的封装。这种支持是即用即插的MultipartResovler实现的；  
springmvc使用ApacheCommons FileUpload 技术实现了一个MultipartReslover实现类；  
文件上传配置：

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
            
            <property name="defaultEncoding" value="utf-8"></property>
            
            <property name="maxUploadSize" value="10485760"/>
            <property name="maxInMemorySize" value="40960"/>
        </bean>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>文件上传</title>
    </head>
    <body>
    <form action="${pageContext.request.contextPath}/upload" enctype="multipart/form-data" method="post">
        <input type="file" name="file">
        <input type="submit" value="上传">
    </form>
    </body>
    </html>

@Controller
    public class UpLoadFile {
        @RequestMapping("/upload")
        public String fileUpload2(@RequestParam("file")CommonsMultipartFile file, HttpServletRequest request) throws IOException {
            //上传路径保存设置
            String path = request.getServletContext().getRealPath("/upload");
            File realPath = new File(path);
            if(!realPath.exists()){
                realPath.mkdir();
            }
            //上传文件地址
            System.out.println("上传文件路径地址:"+realPath);
    
            //通过CommonsMultipartFile的方法直接写文件
            file.transferTo((new File(realPath + "/"+ file.getOriginalFilename())));
            return "redirect:/index.jsp";
        }
    
    }
    重点需要注意的两点是：
      ·文件上传时，form表单的method必须是post
      ·form表单必须加上enctype="multipart/form-data"属性

**文件下载**  
1、设置response响应头  
2、读取文件 inputStream  
3、写出文件 OutputStream  
4、执行操作  
5、关闭流（先开后关）

@RequestMapping("/download2")
        public String fileDownload3(HttpServletRequest request, HttpServletResponse response) throws IOException {
                //要下载图片
            String path = request.getServletContext().getRealPath("/upload");
            String fileName = "1.jpg";
            //1.设置response响应头
            response.setContentType("multipart/form-data");//二进制传输数据
            response.setCharacterEncoding("UTF-8");//设置字符编码
            response.reset();//设置页面不缓存,清空buffer
            //设置响应头
            response.setHeader("Content-Disposition","attachment;fileName="+ URLEncoder.encode(fileName,"utf-8"));
            File file1 =new File(path,fileName);
            //读取文件输入流
            InputStream inputStream = new FileInputStream (file1);
            //3、写出文件 输出流
            OutputStream outputStream = response.getOutputStream();
    
            byte[] bytes = new byte[1024];
            int len = 0;
            //执行写出操作
            while((len=inputStream.read(bytes))!=-1){
                outputStream.write(bytes,0,len);
                outputStream.flush();
            }
    
            //关闭操作
            outputStream.close();
            inputStream.close();
    
    
            return "ok";
        }

## MyBatis ##

是一款优秀的**持久化层**框架，它支持定制化sql、存储过程已经高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集，可以使用简单的XML或注解来配置和映射原生信息，将接口和java的Pojo(普通java对象)映射成数据库中的记录（采用ORM思想就是把数据库表和实体类的属性对应起来让我们可以通过操作实体类就实现操作数据库表 ）  
user User  
id userId  
user\_name userName  
**持久化**就是将程序的数据在持久状态和瞬时状态转化的过程  
数据库（jdbc）io文件持久化  
**持久层**，相当于以前的dao层，完成持久化工作的代码块，层界限十分明显  
**优点**：简单易学、灵活、sql和代码的分离，提高了可维护性、提供映射标签，支持对象与数据库的orm字段关系映射、提供对象关系映射标签，支持对象关系组件维护、提供xml标签，支持编写动态sql  
与数据库等相关配置如下：  
引入jar包:

<dependencies>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.4.5</version>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.6</version>
            </dependency>
    
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.12</version>
            </dependency>
    
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
    
        </dependencies>

SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        
        <environments default="mysql">
            
            <environment id="mysql">
                
                <transactionManager type="JDBC" />
                
                <dataSource type="POOLED">
    
    
    
    
    
    
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/db_hotel_ssm"/>
                    <property name="username" value="root"/>
                    <property name="password" value="qianjiang"/>
    
                </dataSource>
            </environment>
    
    
        </environments>
        
        <mappers>
            <mapper resource="com/qj/item/dao/IUserDao.xml" />
            
    
        </mappers>
    </configuration>

Mybatis映射方式：xml方式、注解方式  
xml形式来配置:如对用户的查询![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70_pic_center 1]

IUserDao.xml:

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    
    <mapper namespace="com.qj.item.dao.IUserDao">
        
        <select id="findAll" resultType="com.qj.item.domain.User">
            select * from role
        </select>
    </mapper>

注意如果数据库字段名与我们java实体类的变量名不一致  
解决方案：（针对查询语句）  
1、起别名  
2、resultMap的配置

<resultMap id="userMap" type="com.qj.item.domain.User">
            
            <id property="userId" column="id"></id>
            
            <result property="userName" column="name"></result>
            <result property="userRemark" column="remark"></result>
        </resultMap>
         
        <select id="findAll"  resultMap="userMap">
            select * from role
        </select>

**动态sql**  
动态 SQL 是 MyBatis 的强大特性之一。JDBC 原生根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 7]  
if：利用if实现简单的条件选择。  
choose(when,otherwise)：相当于java中的switch语句，通常与when和otherwise搭配。  
set：解决动态更新语句。  
trim：灵活的去除多余的关键字。  
foreach：迭代一个集合，通常用于in条件。  
(1)if+where实现多条件查询

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.qj.item.dao.IUserDao">
        <resultMap id="User" type="com.qj.item.entity.User">
            <id column="id" property="id"/>
            <result column="name" property="userName"/>
        </resultMap>
        <select id="selectUserById"  resultMap="User">
            select * from m_user
            <where>
                <if test="id != null">
                    id = #{id}
                </if>
                <if test="name != null and name != ''">
                    and `name` = #{name}
                </if>
            </where>
        </select>
    </mapper>

dao层:

User selectUserById(String userName, Integer id);

小结:  
where元素可以智能的处理and 和 or 的多余问题， 不需担心多余关键字导致语法错误。  
if元素的test用于判断表达式是否符合，符合则继续拼接SQL语句  
(2)if+trim+foreach实现**多条件查询(批量查询**)（重要）

<!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.qj.item.dao.IUserDao">
    <resultMap id="User" type="com.qj.item.entity.User">
            <id column="id" property="id"/>
            <result column="name" property="userName"/>
        </resultMap>
       <select id="selectUsersByIds" resultMap="User">
            select * from m_user
            <trim prefix="where" prefixOverrides="and | or">
                <if test="idList != null">
                    id in
                    <foreach collection="idList" item="id" open="(" close=")" separator=",">
                        #{id}
                    </foreach>
                </if>
                <if test="gender != null and gender != 0">
                    AND gender = #{gender}
                </if>
            </trim>
    </select>
    </mapper>

dao层：

List<User> selectUsersByIds(@Param("idList") List<Integer> idList, @Param("gender") Integer gender);

controller层：

@GetMapping("/users")
        public List<User> selectUsersByIds() {
            List<Integer> idList = new ArrayList<>();
            idList.add(1);
            idList.add(2);
            idList.add(3);
            idList.add(4);
            idList.add(5);
            return userDao.selectUsersByIds(idList, null);
        }

最终sql语句：  
SELECT \* from sysuser where USERID in (1，2,，3，4，5)  
trim的属性：  
prefix：前缀: 作用是通过自动识别是否有返回值后，在trim包含的内容上加上前缀，如上述示例的where。  
suffix：后缀: 作用是在trim包含的内容上加上后缀。  
prefixOverrides:：对于trim包含内容的首部进行指定内容，(如上述示例的 and | or) 的忽略(去余);  
suffixOverrides:：对于trim包含内容的首位部进行指定内容的忽略。  
foreach的属性：  
item：表示集合中每一个元素进行迭代时的别名。  
index:：指定一个名称，表示在迭代的过程中，每次迭代到的位置。  
open：表示该语句以什么开始(既然是in条件语句，必然是 ’ ( ’ 开始)  
separator:：表示每次进行迭代的时候以什么符号作为分隔符(既然是in条件语句，必然是 ’ ， ’ 分隔)  
close:：表示该语句以什么结束(既然是in条件语句，必然是 ’ ) ’ 结束)  
collection：最关键，并且最容易出错的属性。需注意，该属性必须指定，不同情况下，该属性值是不同的，  
注意：若传入的参数是单数且类型为List的时候，属性值为list;  
若传入的参数是单数且类型为数组的时候，属性值为array;  
若传入的参数是单数且类型为map的时候，属性值为Map的key;  
(3)**set**  
set元素可以用于动态包含需要更新的列，忽略其它不更新的列。

<!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.qj.item.dao.IUserDao">
    <resultMap id="User" type="com.qj.item.entity.User">
            <id column="id" property="id"/>
            <result column="name" property="userName"/>
        </resultMap>
      <update id="updateAuthorIfNecessary">
            update  sysuser
            <set>
                <if test="userName != null and userName != ''">
                   `name` = #{userName},
                </if>
                <if test="gender != null and gender != 0">
                    gender = #{gender},
                </if>
                <if test="age != null and age != 0">
                    age = #{age},
                </if>
            </set>
            where id=#{id}
    </update>
    </mapper>

dao 层：

int updateAuthorIfNecessary(User user);

set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）  
另外一种方式：

<!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.qj.item.dao.IUserDao">
    <resultMap id="User" type="com.qj.item.entity.User">
            <id column="id" property="id"/>
            <result column="name" property="userName"/>
        </resultMap>
      <update id="updateAuthorIfNecessary">
            update m_user
            <trim prefix="SET" suffixOverrides=",">
                <if test="userName != null and userName != ''">
                    `name` = #{userName},
                </if>
                <if test="gender != null and gender != 0">
                    gender = #{gender},
                </if>
                <if test="age != null and age != 0">
                    age = #{age},
                </if>
            </trim>
            where id=#{id}
        </update>
    </mapper>

（4）**choose**  
相当于Java中的switch语句，通常与when和otherwise搭配。  
有时候，我们不想使用所有的条件，而只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句

<!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.qj.item.dao.IUserDao">
    <resultMap id="User" type="com.qj.item.entity.User">
            <id column="id" property="id"/>
            <result column="name" property="userName"/>
        </resultMap>
    <select id="selectUsersByName" resultMap="User">
            select * from m_user where age = 19
            <choose>
                <when test="userName != null and userName != ''">
                    and `name` = #{userName}
                </when>
                <otherwise>
                    AND gender = 1
                </otherwise>
            </choose>
    </select>
    </mapper>

(5)**Bind**  
这种方式使用的不是很多，但是也是有用的。bind 元素允许你在 OGNL 表达式以外创建一个变量，并将其绑定到当前的上下文

(6)script

@Update({"<script>",
          "update m_user",
          "  <set>",
          "    <if test='username != null'>`name`=#{username},</if>",
          "    <if test='gender != null and gender != 0'>gender=#{gender},</if>",
          "  </set>",
          "where id=#{id}",
          "</script>"})
        void updateUserValues(User user);

小结：  
表中是否已经有索引，有索引的时候我们的SQL中是否有用上。  
返回字段尽量不要写星号\*，建议写成需要的字段。  
关键字建议都写成大写，更好的区别非关键字。  
遇到表中字段和数据库关键一样的时候，记得单引号。  
使用@Param注解注意一定要使用Mybatis中的注解。  
使用不管是一个参数还是多个参数时，使用注解@Param指定名称，方便日后需要再次添加字段。  
强烈建议使用动态标签，避免出现多出and或者or关键字的SQL错误，同时也不用再写where 1=1  
**用dao的接口来编写**  
很明显没有在resourse下面创建com.qj.item.dao,然后配置文件IUserDao.xml自然不需要了  
crud四组注解:  
@Select,@Insert,@Delete,@Update  
使用注解形式：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70_pic_center 2]  
此时的SqlMapConfig.xml其他都一样 这里需要改动下：

然后在持久层打注解：

public interface IUserDao {
        /**
         * 查询所有操作
         * @return
         */
        @Select("Select* from role")
        List<User> findAll();
    }

//1. 读取配置文件
            InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
            绝对路径：D:/xxx/xxx.xml(X)
            相对路径：src/java/main/xxx.html(X)
            加载文件 使用类加载器，他只能读取类里面的配置文件
            使用ServletContext对象的getRealPath()
            //2. 创建SqlSessionFactory工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            SqlSessionFactory factory = builder.build(inputStream);
            创建工厂mybatis使用构建者模式   构建者模式：把对象的创建细节隐藏，是使用者直接调用方法即可拿到对象
            //3. 使用工厂生产SqlSession对象
            SqlSession session = factory.openSession();
            生产SqlSession使用了工程模式 优势：解耦（降低类之间的依赖关系）
            //4. 使用SqlSession创建Dao接口的代理对象
            IUserDao userDao = session.getMapper(IUserDao.class);
            创建Dao接口实现类使用代理模式  优势：不修改源码的基础上对已有方法增强
            //5. 使用代理对象执行方法
            List<User> users = userDao.findAll();
            //关闭资源
             sqlSession.close();
            inputStream.close();

出现的问题：  
1、注解时候做@insert 和@update，由于引入了外键，所以无法执行增加和更新操作，所以在设计表的时候注意这个问题就ok;  
2、模糊查询的时候 sql语句中不加%，`@Select("select * from account where username like #{username}")`那么在测试代码中加

List<User> userList = iUserDao.fuzzyGetUsers("%涛%");

或者在sql语句中这样写：

//    @Select("select * from ylrc_user where username like #{username}")
        @Select("select * from ylrc_user where username like '%${value}%'")
       List<User> fuzzyGetUsers(String username);
    
    
    //        List<User> userList = iUserDao.fuzzyGetUsers("%涛%");
            List<User> userList = iUserDao.fuzzyGetUsers("涛");
            for (User user:userList){
                System.out.println(user);
            }

3、查的时候，我当时做测试模糊查询的时候，发现sql语句是正确的。但是就在我java代码中就怎么也查不出结果，所以需要看看db.properties文件配置了。  
4、**如果实体类的字段名没有根数据库的列名对应起来怎么办**？  
使用Results和 @Result解决

@Select("select * from account")
        @Results(id="accoutMap",value = {
                @Result(id = true,column = "id",property = "id_as"),
                @Result(column = "email",property = "email_as"),
                @Result(column = "mobile",property = "mobile_as"),
                @Result(column = "password",property = "password_as"),
                @Result(column = "username",property = "username_as")
        })
        List<User> getUserList();

其他语句也要使用那么就在@Results(id=xxx)

/**
         * 根据姓名模糊查询
         */
    //    @Select("select * from account where username like #{username}")
        @Select("select * from account where username like '%${value}%'")
        @ResultMap(value = {"accoutMap"})或者 @ResultMap("accoutMap")
       List<User> fuzzyGetUsers(String username);

注解入门：  
不需要IUserDao.xml，在dao接口的方法上使用@Select注解，并且指定sql语句，同时需要在SqlMapConfig.xml中的mapper配置时，使用class属性指定dao接口全限定名

我们实现多对一(mybatis中称为一对一)的配置

public class Student {
        private int id;
        private String create_time;
        private String update_time;
        private String academy;
        private String grade;
        private String mobile;
        private String nickname;
        private String qq;
        private String school;
    	private int uid;
        //多对一(mybatis中称为一对一)的映射：一个学生只能属于一个用户
        private  User user;
    
        public User getUser() {
            return user;
        }
    
        public void setUser(User user) {
            this.user = user;
        }
     }

public interface IStudentDao {
    
        /**
         * 查询学生信息
         */
        @Select("select * from studnet")
        @Results(id = "accountMap",value = {
                @Result(id = true,column = "id",property = "id"),
                @Result(column = "uid",property = "uid"),
                @Result(column = "grade",property = "grade"),
                @Result(column = "mobile",property = "mobile"),
                @Result(column = "nickname",property = "nickname"),
                @Result(property = "user",column = "uid",one = @One(select = "com.qj.item.dao.IUserDao.getById",fetchType = FetchType.EAGER))
        })
        List<Student> findAll();
    
    }

只是测试，不必在乎结果

List<Student> studentList = iStudentDao.findAll();
            for(Student student:studentList){
                System.out.println("----每个学生信息-----");
                System.out.println(student);
                System.out.println(student.getUser());
            }
    ----每个学生信息-----
    Student{id=2, academy='计算机科学与技术学院', uid='1', grade='软件1102', mobile='13656565656', nickname='豆皮江爱唱歌'}
    User{id=1, email='ylrc@qq.com', mobile='13356565656', password='123456', username='生活加点糖'}

我们实现一对多的配置，一个用户对应多个学生

//通过用户id来查询学生信息
        @Select("select * from studnet where uid = #{id}")
        List<Student> getByIdStudents(int id);

@Select("select * from user")
        @Results(id = "userMap",value = {
                @Result(id = true,column = "id",property = "id_as"),
                @Result(column = "email",property = "email_as"),
                @Result(column = "mobile",property = "mobile_as"),
                @Result(column = "password",property = "password_as"),
                @Result(column = "username",property = "username_as"),
                @Result(property = "studentList" ,column = "id",many =@Many(select = "com.qj.item.dao.IStudentDao.getByIdStudents",fetchType = FetchType.LAZY))
        })
        List<User> getUserList();

@Test()
        public void selectTest(){
            List<User> userList=iUserDao.getUserList();
            for(User user:userList){
                System.out.println("-----每个用户的信息-------");
                System.out.println(user);
                System.out.println(user.getStudentList());
            }
        }
    User{id=1, email='ylrc@qq.com', mobile='13356565656', password='123456', username='生活加点糖'}
    [Student{id=2, academy='计算机科学与技术学院', uid='1', grade='软件1102', mobile='13656565656', nickname='豆皮江爱唱歌'}]

`#{}`和 `${}`的区别是什么？  
\#\{\}是预编译处理，`${}`是字符替换;在使用 \#\{\}时，MyBatis 会将 SQL 中的 \#\{\}替换成“?”，配合 PreparedStatement 的 set 方法赋值，这样可以有效的防止 SQL 注入，保证程序的运行安全  
**MyBatis 有几种分页方式?**  
分页方式：逻辑分页和物理分页。  
逻辑分页： 使用 MyBatis 自带的 RowBounds 进行分页，它是一次性查询很多数据，然后在数据中再进行检索。这样做弊端是需要消耗大量的内存、有内存溢出的风险、对数据库压力较大。  
物理分页： 自己手写 SQL 分页或使用分页插件 PageHelper，去数据库查询指定条数的分页数据的形式。比如需要大量的内存，对数据库查询压力较大等问题。

**总结常用的注解**  
1、

@MapperScan("com.qj.*mapper")
    public class UserMapper(){
    }
    @MapperScan("com.qj.mapper","com.qj.mapper1")
    public class UserMapper(){
    }

扫描想要被扫描的包路径  
2、@Mapper

@Mapper
    public interface UserMapper{
    		User getUserById(Interge id);
    }

该注解为了不再写mapper映射文件（UserMapper.xml）,描述数据层接口的注解  
3、**@Insert**手动指定主键应用层、  
自增主键（数据层单层）

/**
    * 插入记录，数据库生成主键 
    */
    @Options(useGeneratedKeys = true, keyProperty = "id")
    @Insert("INSERT INTO t_user (username, passwd) VALUES (#{username}, #{passwd})")
    int addUserGeneratedKey(User user);

使用Option来对应着XML设置的select标签的属性，userGeneratordKeys表示要使用自增主键，keyProperty用来指定主键字段的字段名。自增主键会使用数据库底层的自增特性  
**选择主键（数据层多表）**

/**
     * 插入记录，选择主键 
     */
    @Insert("INSERT INTO t_user (username, passwd) VALUES (#{username}, #{passwd})")
    @SelectKey(statement = "SELECT UNIX_TIMESTAMP(NOW())", keyColumn = "id", keyProperty = "id", resultType = Long.class, before = true)
    int addUserSelectKey(User user);

选择主键从数据层生成一个值，并用这个值作为主键的值  
4、@Delete

/**
     * 删除记录 
     */
    @Delete("DELETE FROM t_user WHERE id=#{id}")
    int delete(Long id);

5、@Update

/**
     * 修改记录 
     */
    @Update("UPDATE t_user SET username=#{username}, passwd=#{passwd} WHERE id=#{id}")
    int update(User user);

6、**@Select重点**  
指定别名

/**
     * 根据ID查询，手动设置别名 
     */
    @Select("SELECT id, username, passwd, birth_day AS birthDay FROM t_user WHERE id=#{id}")
    User loadByIdHandAlias(Long id);

**使用mybatis的自动下划线驼峰转换**  
mybatis中的mapUnderscoreToCamelCase,当**表中的字段名与对象名相同只是下划线和驼峰写法的差异时适用**  
7、**@ResultMap**使用表的字段名和对象的属性名没有太大相同点并且表中的字段挺多的情况下，应该使用ResultMap做适配

@Results(id = "userMap", value = {
            //可以使用这种方式来处理字段名和数据库表字段名不一致的情况
            @Result(id=true, column = "id", property = "id"),
            @Result(column = "username", property = "username"),
            @Result(column = "passwd", property = "passwd"),
            @Result(column = "birth_day", property = "birthDay")
    })
    @Select("SELECT * FROM t_user WHERE id=#{id}")
    User loadByIdResultMap(Long id);

@Results对应着XML中的ResultMap，同时可以为其指定一个id，其它地方可以使用这个id来引用它，比如要引用上面id的userMap

@ResultMap("userMap")
    @Select("SELECT * FROM t_user WHERE id=#{id}")
    User loadByIdResultMapReference(Long id);

使用@ResultMap来引用一个已经存在的ResultMap，这个ResultMap可以是在Java中使用@Results注解定义的，也可以是在XML中使用resultMap标签定义的  
8、@Results:结果映射的列表, 包含了一个特别结果列如何被映射到属性或字段的详情。属 性:value, id。value 属性是 Result 注解的数组。对应xml中的`<resultMap>` 标签。  
9、@Result:在列和属性或字段之间的单独结果映 射。属 性:id,column, property, javaType ,jdbcType ,type Handler, one,many。id 属性是一个布尔值,表 示了应该被用于比较(和在 XML 映射 中的相似)的属性。one 属性是单 独 的 联 系, 和 `<association>` 相 似 , 而 many 属 性 是 对 集 合 而 言 的 , 和 `<collection>`相似。它们这样命名是为了 避免名称冲突。类似于`<resultMap>`的子标签 ```<result>``<id>```。  
10、@One：复杂类型的单独属性值映射。属性: select,已映射语句(也就是映射器方 法)的完全限定名,它可以加载合适类 型的实例。注意:联合映射在注解 API 中是不支持的。这是因为 Java 注解的 限制,不允许循环引用。类似于`<association>`标签。  
11、@Many：与@One类似，一对多的关系，类似于`<collection>`  
12、@Param :参数标签，我们在Mapper的方法签名上标注的参数，我们可以指定参数名称，然后在注解中或者xml中的SQL里就可以使用我们自定义的参数名称。  
13、@SelectKey ：获取最新插入id。  
14、@CacheNamespace ：为给定的命名空间 (比如类) 配置缓存。对应xml中的`<cache>`  
15、@CacheNamespaceRef ：参照另外一个命名空间的缓存来使用。属性:value,应该是一个名空间的字 符串值(也就是类的完全限定名) 。对应xml中的`<cacheRef>`标签。  
16、@ConstructorArgs ：收集一组结果传递给一个劫夺对象的 构造方法。属性:value,是形式参数 的数组。  
17、@Arg ：单 独 的 构 造 方 法 参 数 , 是 ConstructorArgs 集合的一部分。属性: id,column,javaType,typeHandler。id 属性是布尔值, 来标识用于比较的属 性,和XML 元素相似。对应xml中的`<arg>`标签。  
18、@Case ：单独实例的值和它对应的映射。属性: value,type,results。Results 属性是结 果数组,因此这个注解和实际的 ResultMap 很相似,由下面的 Results 注解指定。对应xml中标签`<case>`。  
mybatis最初配置信息是基于 XML ，MyBatis 3提供了新的基于注解的配置  
**增删改查**:@Insert、@Update、@Delete、@Select、@MapKey、@Options、@SelelctKey、@Param、@InsertProvider、@UpdateProvider、@DeleteProvider、@SelectProvider  
**结果集映射:**@Results、@Result、@ResultMap、@ResultType、@ConstructorArgs、@Arg、@One、@Many、@TypeDiscriminator、@Case  
**缓存:**@CacheNamespace、@Property、@CacheNamespaceRef、@Flush  
**注意**:绝大部分注解，在xml映射文件中都有元素与之对应，但是不是所有。此外在mybatis-spring中提供了@Mapper注解和@MapperScan注解，用于和spring进行整合。  
注解和它xml中的标签

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 8]  
小结：  
注解和xml不可以共存，但是可以结合使用，也就是说同一个方法不能同时存在xml和注解  
**高级映射**  
**(1)association**  
映射到JavaBean的某个复杂的”数据类型”属性，仅处理一对一的关联关系

association的属性节点：  
(1)property:映射数据库列的实体对象属性名。  
(2)javaType:完整的java类名和限定名。propert所映射的属性的类型。  
子元素  
(1)id:一般为映射主键，可以提高性能。  
(2)result:  
column:映射的数据库的字段名。  
property:映射的数据列对应的实体对象属性  
**collection**

映射到JavaBean的某个复杂的”数据类型”属性，这个属性是一个集合列表，处理一对多的关联关系

ofType：完整的Java类名和限定名。propert所映射的属性的类型。  
其余和association基本一致。  
association和collection都具备延迟加载功能。  
延迟加载：先从单表查询，需要时再查关联表，大大的提高了数据库性能，因为相对来说单表查询比多表查询要快

**延迟加载和立即加载**  
延迟加载：在真正使用数据时才发起查询不用的时候不查询。按需加载（懒加载）  
延迟加载的原理的是调用的时候触发加载，而不是在初始化的时候就加载信息。比如调用 a. getB(). getName()，这个时候发现 a. getB() 的值为 null，此时会单独触发事先保存好的关联 B 对象的 SQL，先查询出来 B，然后再调用 a. setB(b)，而这时候再调用 a. getB(). getName() 就有值了，这就是延迟加载的基本原理  
立即加载：不管用不用，只要一调用方法，马上发起查询  
四中表关系：  
一对多，多对多：通常情况下我们采用延迟加载  
sqlMapConfig.xml

多对一，一对一：通常情况下我们采用立即加载  
**缓存**  
存在于内存中的临时数据  
使用缓存可以减少和数据库交互次数，提高执行效率  
什么时候使用缓存，什么时候不适用缓存呢？  
适用于缓存：经常查询并且不经常改变的，  
数据的正确与否对最终结果影响不大  
不适用缓存：经常改变的数据、数据的正确与否对最终结果影响很大的  
例如：商品的库存，银行的汇率，股市的牌价  
**一级缓存**  
它指的是Mybatis中**sqlsession**对象的缓存。当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供一块区域中。该区域的结构是一个Map。当我们再次查询同样的数据，mybatis会先去sqlsession中查询是否有，有的话直接拿出来用，当SqlSession对象消失时，mybatis的一级缓存也就消失了

@Test()
        public void testFirstLevelCache(){
            User user1 = userDao.findId(6);
            System.out.println(user1);
           // sqlSession.close();
    
            //再次获取SqlSession对象
            //sqlSession = factory.openSession();
            //这样关闭缓存
            sqlSession.clearCache();
            userDao = sqlSession.getMapper(IUserDao.class);
    
            User user2 = userDao.findId(6);
            System.out.println(user2);
            System.out.println(user1==user2);//false
    
        }

一级缓存是SqlSession范围的缓存，当调用SqlSession的修改，添加，删除，commit(),close()，clearCache()等方法时，就会清空一级缓存,默认一级缓存是开启的  
**二级缓存**  
它指的是Mybatis中SqlSessionFactory对象的缓存，由同一个SqlSessionFactory对象创建的SqlSession共享其缓存  
也是基于 PerpetualCache 的 HashMap 本地缓存，不同在于其存储作用域为 Mapper 级别的，如果**多个SQLSession之间需要共享缓存，则需要使用到二级缓存**，并且二级缓存可自定义存储源，如 Ehcache。默认不打开二级缓存，要开启二级缓存，使用二级缓存属性类需要实现 Serializable 序列化接口(可用来保存对象的状态  
**开启二级缓存数据查询流程：二级缓存 -> 一级缓存 -> 数据库。**  
缓存更新机制：当某一个作用域(一级缓存 Session/二级缓存 Mapper)进行了C/U/D 操作后，默认该作用域下所有 select 中的缓存将被 clear  
二级缓存使用步骤：  
1、让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）

2、让当前的映射文件支持二级缓存（在IUserDao.xml中配置）  
3、让当前的操作支持二级缓存（在select标签中配置）

<cache/>
        <select id="findId" useCache="true" parameterType="java.lang.Integer" resultType="com.qj.item.pojo.User">
            select * from ylrc_user where id = #{id}
        </select>

二级缓存存放的内容是数据，而不是对象

@Test()
        public void tesTwoLevelCache(){
          SqlSession sqlSession1 = factory.openSession();
            IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
            User user1 = dao1.findId(6);
            System.out.println(user1);
            sqlSession.close();//一级缓存消失
            
            SqlSession sqlSession2 = factory.openSession();
            IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);
            User user2 = dao2.findId(6);
            System.out.println(user2);
            sqlSession2.close();
            System.out.println(user1==user2);
        }

注解方式:  
1、让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）

2、注解一步搞定

@CacheNamespace(blocking = true)
    public interface IUserDao {
    }

MyBatis 和 hibernate 的区别有哪些？  
灵活性：MyBatis 更加灵活，自己可以写 SQL 语句，使用起来比较方便。  
可移植性：MyBatis 有很多自己写的 SQL，因为每个数据库的 SQL 可以不相同，所以可移植性比较差。  
学习和使用门槛：MyBatis 入门比较简单，使用门槛也更低。  
二级缓存：hibernate 拥有更好的二级缓存，它的二级缓存可以自行更换为第三方的二级缓存

## spring内置的 JdbcTemplate(spring-jdbc) ##

pom.xml文件中：

<build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>8</source>
                        <target>8</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>5.1.9.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.1.9.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.12</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.26</version>
            </dependency>
    
            <dependency>
                <groupId>commons-dbcp</groupId>
                <artifactId>commons-dbcp</artifactId>
                <version>1.4</version>
            </dependency>
    
            <dependency>
                <groupId>com.mchange</groupId>
                <artifactId>c3p0</artifactId>
                <version>0.9.5.5</version>
            </dependency>
            <dependency>
                <groupId>com.mchange</groupId>
                <artifactId>mchange-commons-java</artifactId>
                <version>0.2.20</version>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.21</version>
            </dependency>
        </dependencies>

在application文件中配置多个数据库连接池：  
application.xml:

User类：

public class User  implements Serializable {
    
        private int id;
        private String username;
        private String password;
        private String updateByLast;
        private String creatByTime;
        }

测试代码:

public class TestDao {
        private JdbcTemplate jdbcTemplate;
        private ApplicationContext applicationContext;
        @Before
        public void init(){
            applicationContext =
                    new ClassPathXmlApplicationContext("application.xml");
         this.jdbcTemplate=applicationContext.getBean("jdbcTemplate1",JdbcTemplate.class);
        }
        @Test
        public void getUserLists(){
            String sql = "select * from user";
            List<User> userList = this.jdbcTemplate.query(sql,new BeanPropertyRowMapper<User>(User.class));
           userList.forEach(System.out::println);
        }
        //查询
        public  List<User> getUsers(){
           // jdbcTemplate.query();
            init();
            String sql = "select * from user";
            List<User> userList = this.jdbcTemplate.query(sql,new BeanPropertyRowMapper<User>(User.class));
            return userList;
        }
        //插入
        public int insert(User user){
            init();
            String sql = "insert into user (username,password) values('"+user.getUsername()+"',"+user.getPassword()+")";
            int count = this.jdbcTemplate.update(sql);
            return count;
        }
        //删除
        public int delete(int id){
            init();
            String sql="delete from user where id = ?";
            int count = this.jdbcTemplate.update(sql,id);
            return count;
        }
        //更新
        public int update(User user){
            init();
            String sql = "update user set username=?,password=? where id=?";
            int count = this.jdbcTemplate.update(sql,user.getUsername(),user.getPassword(),user.getId());
            return count;
        }
        //根据id得到用户
        public User getOne(int id){
            init();
            String sql ="select * from user where id="+id;
            return this.jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<User>(User.class));
        }
        @Test
        public void getUserList(){
           List<User> userList = getUsers();
           userList.forEach(System.out::println);
        }
        @Test
        public void insertUser(){
            User user = new User();
            user.setUsername("妮妮");
            user.setPassword("323232");
            int i =insert(user);
            System.out.println("影响记录数:"+i);
        }
        @Test
        public void deleteUser(){
            int i =delete(1);
            System.out.println("影响记录数:"+i);
        }
        @Test
        public void updateUser(){
            User user = new User();
            user.setUsername("化化");
            user.setPassword("3233111");
            user.setId(23);
            int i=update(user);
            System.out.println("影响记录数:"+i);
        }
        @Test
        public void getOne(){
            User user =getOne(1);
            System.out.println(user);
        }
        //得到总记录数
        @Test
        public void getCount(){
            List count  = this.jdbcTemplate.queryForList("select * from user ");
            System.out.println(count.size());//得到总记录数
    
        }
    
        //根据姓名来查询
        public User getUserByName(String name){
            User user=this.jdbcTemplate.queryForObject("select * from user where username ='"+name+"'",new BeanPropertyRowMapper<User>(User.class));
          return user;
        }
        @Test
        public void getByName(){
            User user =getUserByName("化化");
            System.out.println(user);
        }
    }
    User{id=23, username='化化', password='3233111', updateByLast='null', creatByTime='null'}

jdbcTemplate方法的使用  
1、UPDATE或INSERT,可以用update()方法

jdbcTemplate.update("INSERT INTO USER VALUES('" 
               + user.getId() + "', '" 
               + user.getName() + "', '" 
               + user.getSex() + "', '" 
               + user.getAge() + "')");

2、带参数的更新

jdbcTemplate.update("UPDATE USER SET name = ? WHERE user_id = ?", new Object[] {name, id});

jdbcTemplate.update("INSERT INTO USER VALUES(?, ?, ?, ?)", new Object[] {user.getId(), user.getName(), user.getSex(), user.getAge()});

3、使用JdbcTemplate进行查询时，使用queryForXXX()等方法  
可以自己去查看源码。。。。。

## spring+mybatis的整合 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 9]  
application.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">
        <import resource="spring-dao.xml"></import>
    
    </beans>

spring-dao.xml:

SqlMapConfig.xml:

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        
        
        
        
        <typeAliases>
            <package name="com.qj.pojo"/>
        </typeAliases>
    
        <mappers>
            <package name="com.qj.dao"/>
        </mappers>
    </configuration>

Hobby类：

import java.io.Serializable;
    
    public class Hobby implements Serializable {
        private int id;
        private String hobbyname;
    }

Student类：

import java.io.Serializable;
    
    
    public class Student implements Serializable {
        private int id;
        private String name;
        private String birthday;
        private String sex;
        private String hobbyname;
    }

IHobbyDao:

import org.apache.ibatis.annotations.Select;
    import org.mybatis.spring.annotation.MapperScan;
    
    @MapperScan
    public interface IHobbyDao {
    
        @Select("Select t_hobby.hobbyname from t_hobby where t_hobby.id=#{id}")
        String getHobbyById(int id);
        
    }

IHobbyDao:

import com.qj.pojo.Student;
    import org.apache.ibatis.annotations.Many;
    import org.apache.ibatis.annotations.Result;
    import org.apache.ibatis.annotations.Results;
    import org.apache.ibatis.annotations.Select;
    import org.apache.ibatis.mapping.FetchType;
    import org.mybatis.spring.annotation.MapperScan;
    
    
    import java.util.List;
    
    @MapperScan
    public interface IStudentDao {
    
        @Select("Select t_student.id,t_student.name,t_student.birthday,t_student.sex,t_hobby.hobbyname from t_student ,t_hobby where t_student.id=t_hobby.id")
        @Results(id ="stuMap",value={
                @Result(id = true,column = "id",property = "id"),
                @Result(column = "name",property = "name"),
                @Result(column = "birthday",property = "birthday"),
                @Result(column = "sex",property = "sex"),
                @Result(property = "hobbyname",column="id",many = @Many(select = "com.qj.dao.IHobbyDao.getHobbyById",fetchType = FetchType.LAZY))
        })
        List<Student> getStudents();
        
    }

Test:

import com.qj.dao.IStudentDao;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class TestSpringMybatis {
    
        @Test
        public void test(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
            IStudentDao iStudentDao =(IStudentDao) applicationContext.getBean("IStudentDao");
            iStudentDao.getStudents().forEach(System.out::println);
        }
        
    }
    Student{id=2, name='李四', birthday='1998-08-01', sex='女', hobbyname='篮球'}
    Student{id=3, name='张无忌', birthday='2000-08-03', sex='男', hobbyname='排球'}
    Student{id=5, name='李四', birthday='2000-08-03', sex='女', hobbyname='羽毛球'}

pom.xml:

<dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>5.1.9.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.1.9.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.12</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.5.2</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>2.0.2</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.26</version>
            </dependency>
            <dependency>
                <groupId>commons-dbcp</groupId>
                <artifactId>commons-dbcp</artifactId>
                <version>1.4</version>
            </dependency>
        </dependencies>

## SSM的整合 ##

web.xml文件的配置:

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
             http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
             version="3.1">
    
      <filter>
        <filter-name>shiroFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
      </filter>
      <filter-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
      </filter-mapping>
    
    
      <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
      </context-param>
      
      <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
    
      <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        
        <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
      </servlet>
    
      <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
      </servlet-mapping>
    
      
      <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
          <param-name>encoding</param-name>
          <param-value>UTF-8</param-value>
        </init-param>
      </filter>
      <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
      </filter-mapping>
    </web-app>

pom文件:

<dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
        </dependency>
        
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.5</version>
        </dependency>
        <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>javax.servlet.jsp-api</artifactId>
          <version>2.3.3</version>
        </dependency>
        <dependency>
          <groupId>taglibs</groupId>
          <artifactId>standard</artifactId>
          <version>1.1.2</version>
        </dependency>
        <dependency>
          <groupId>jstl</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
        </dependency>
    
        
        <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.21</version>
            </dependency>
        
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>3.5.2</version>
        </dependency>
        
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis-spring</artifactId>
          <version>2.0.2</version>
        </dependency>
        
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.6</version>
        </dependency>
    
        
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
          <version>1.2.12</version>
        </dependency>
     
          <dependency>
              <groupId>org.jetbrains</groupId>
              <artifactId>annotations-java8</artifactId>
              <version>RELEASE</version>
              <scope>compile</scope>
          </dependency>
      </dependencies>

db.properties文件:

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useUnicode=true&characterEncoding=utf8
    jdbc.username=root
    jdbc.password=qianjiang

applicationContext.xml文件配置:

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"      
           xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context-4.0.xsd
            http://www.springframework.org/schema/aop 
            http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
            
    	<context:property-placeholder location="classpath:db.properties"/>
    	
    	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    		
    		
    		 <property name="driverClassName" value="${jdbc.driver}" />
    		<property name="url" value="${jdbc.url}"></property>
            <property name="username" value="${jdbc.username}"></property>
            <property name="password" value="${jdbc.password}"></property>
            
             
            <property name="initialSize" value="1"></property>
            <property name="minIdle" value="1"></property>
            <property name="maxActive" value="200"></property>
            
            <property name="maxWait" value="60000"></property>
            
            <property name="timeBetweenEvictionRunsMillis" value="60000"></property>
            
            <property name="minEvictableIdleTimeMillis" value="300000"></property>
            
            <property name="poolPreparedStatements" value="true"/>
            <property name="maxPoolPreparedStatementPerConnectionSize" value="20"/>
            
            <property name="filters" value="stat"/>
    	</bean>
    	
    	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    		
    		<property name="dataSource" ref="dataSource"></property>
    		
    		<property name="configLocation" value="classpath:mybatis-config.xml"></property>
    	</bean>
    	
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            
            <property name="basePackage" value="com.qj .dao" />
        </bean>
          
        
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        	
        	<property name="dataSource" ref="dataSource"></property>
        </bean>
        
        <tx:annotation-driven transaction-manager="transactionManager"/>
        
        <context:component-scan base-package="com.qj.*">
        	<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>
    
    
     <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
            <property name="securityManager" ref="securityManager"/>
            <property name="loginUrl" value="login.html"/>
            <property name="unauthorizedUrl" value="403.html"/>
            <property name="filterChainDefinitions">
                <value>
                    /login.html = anon
                    /subLogin = anon
                    /* = authc
                </value>
            </property>
        </bean>
        
        <bean class="org.apache.shiro.web.mgt.DefaultWebSecurityManager" id="securityManager">
            <property name="realm" ref="realm"/>
        </bean>
    
        
        <bean class="com.qj.service.CustomRealm" id="realm">
            <property name="credentialsMatcher" ref="credentialsMatcher"/>
        </bean>
        <bean id="credentialsMatcher" class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
            <property name="hashAlgorithmName" value="md5"></property>
            <property name="hashIterations" value="1"></property>
        </bean>
    </beans>

mybatis-config.xml文件：

springmvc-config.xml:  
<mvc:resources />后，允许将静态资源存放在任意的位置，WEB-INF，类路径等等，通过location属性指定静态资源的位置即可，打破了传统web容器静态资源只能放在根路径下的限制  
它拦截了所有请求  
在springmvc-servlet.xml中配置了<mvc:default-servlet-handler />后，可以将静态资源的请求转发给web服务器默认的servlet处理

DateConvert 类:

package co.qj.util;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    import org.springframework.core.convert.converter.Converter;
    
    public class DateConvert implements Converter<String, Date>{
    
    	@Override
    	public Date convert(String arg0) {
    		// TODO Auto-generated method stub
    		Date date=null;
    		try {
    			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
    			date=sdf.parse(arg0);
    		} catch (Exception e) {
    			// TODO: handle exception
    		}
    		return date;
    	}
    
    }

UserDao.xml文件:

User类：

public class User {
        private String name;
        private String birthday;
        private String sex;
        private int hobby;
     }

dao层:

public interface UserDao {
        List<User> selectAllUser();
    }

service层:

public interface UserService {
        List<User> selectAllUser();
    }

@Service("userServiceImp")
    public class UserServiceImp implements UserService {
    
        @Autowired
        private UserDao userDao;
        @Override
        public List<User> selectAllUser() {
            return userDao.selectAllUser();
        }
    }

controller层:

@Controller
    @RequestMapping("/login")
    public class UserController {
        @Autowired
        private UserService userService;
    
        @ResponseBody
        @RequestMapping(method= RequestMethod.GET)
        public String selectAllUser() {
            List<User> list=userService.selectAllUser();
            String result= JSONArray.toJSONString(list);
            return result;
        }
     }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/2c50d3bf79254bec95d408bc53bd4ce0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70]: /images/20221123/7873ee27cb5b4a8d939d23952856bace.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 1]: /images/20221123/123a9207fc9d408d84117fc5d174c01e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 2]: /images/20221123/b31e50fd9f3f4ab199523c3dbd4ce36c.png
[20210208081637269.png]: /images/20221123/2b8667da0ec44d6d8c221e092c82043f.png
[20210208083335846.png]: /images/20221123/2a6861309e1147c796427009cc434589.png
[20210208085900625.png]: /images/20221123/afbd3519ded6432787025c7cb7330d82.png
[20210208090741175.png]: /images/20221123/6734a23737e942a59566f58cd5962f12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 3]: /images/20221123/623bdecd76e34ee7a334cd62c9a449d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 4]: /images/20221123/14ab383b008e455087560e537a7261f8.png
[2021020809581646.png]: /images/20221123/876e2c7bc72042349132fdea99926281.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 5]: /images/20221123/6a8575483d6d42ab8142770e8eaffde4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 6]: /images/20221123/4dca391125d94255b01c44f54493cf91.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/cb84a749ea6a42b1bd8060262ffc4834.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 7]: /images/20221123/bd6fb612546a4f1fbeaf64d5ed180edf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/9bc36c9d523a4181b5cb8e7cac1cd77d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 8]: /images/20221123/b02155dfed4f4c47a3d4bfc80bb8f76f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA5MzcxMQ_size_16_color_FFFFFF_t_70 9]: /images/20221123/8e2487f191a04e57bae82960e4a1183f.png