学习归纳15：SSM(SpringMVC+Spring+MyBatis)框架

已于 2022-11-05 16:17:03 修改
阅读量305 收藏 1
点赞数
文章标签： java
于 2022-09-24 15:19:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52941423/article/details/127025794
版权

目录

Spring：

IoC控制反转：

注解开发：

连接池：

配置文件法：

全注解法：

AOP面向切面：

配置文件法：

 配置文件+注解法：

Spring事务：

编程式事务：

声明式事务：

SpringMVC:

SpringMVC入门步骤：

响应：

 请求：

 接收json类型数据：

接收文件：

其他内容： 

Restful风格：

类型转换器：

全局异常处理器：

拦截器：

Spring和SpringMVC整合：

MyBatis：

MyBatis快速入门：

起别名：

代理开发模式：

动态sql：

if分支：

foreach遍历：

其他内容：

平铺映射：

层叠映射：

注解开发：

SpringMVC用于替代Servlet接收数据

Spring用于替代javase

MyBatis用于替代JDBC连接数据库

Spring：

Spring是分层的Java SE/EE应用，轻量级开源框架，以IoC(Inverse of Control)(控制反转)和AOP(Aspect Oriented Programming)(面向切面编程)为内核

Spring优势：方便解耦，简化开发；方便集成各种优秀框架；方便程序的测试；AOP编程的支持；声明式事务的支持；降低JavaEE API的使用难度；Java源码是经典学习范例

IoC控制反转：

把对象的创建和调用交给Spring进行管理，常用DI(Dependency Injection)(依赖注入)实现，即依赖注入是IoC的具体实现

导入spring

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>

.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">
<!--将dao放进配置文件-->
<!--    bean标签用于配置类，可以有多个；class属性写全限定类名；id属性是名字；scope属性singleton单例(默认)，prototype多例，用于控制多次调用是同一对象还是重新创建;
        单例占用空间少，多例多次创建空间大；单例在加载spring容器时创建对象,多例获取getBean时创建对象;
        init-methon指定初始化方法;destroy-method指定销毁方法-->
    <bean class="com.buka.dao.UserDao" id="userDao" scope="singleton" init-method="init" destroy-method="destroy"></bean>
    <bean class="com.buka.dao.OrderDao" id="orderDao"></bean>
<!--    配置service-->
    <bean class="com.buka.service.UserService" id="userService">
<!--        property通过set方法赋值，constructor-arg通过构造方法赋值，应多用proprity；name是成员变量名，ref是id-->
        <property name="userDao" ref="userDao"></property>
<!--        <constructor-arg name="userDao" ref="userDao"></constructor-arg>-->
    </bean>
</beans>
<!--    分模块开发  主文件中加载分文件-->
    <import resource="applicationContext-user.xml"></import>

web层

package com.buka.web;

import com.buka.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserWeb {
    public static void main(String[] args) {
        //1..创建容器
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.取出对象
        UserService userService = (UserService) app.getBean("userService");
        //3.调用
        userService.show();
    }
}

service层

package com.buka.service;

import com.buka.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserService {
    //public static void main(String[] args) {
//原生方法
//        UserDao userDao = new UserDao();
//        userDao.show();
//Spring IoC
        //1.创建spring容器
        //ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.取出对象
        //UserDao userDao = (UserDao) app.getBean("userDao");
        //3.调用
        //userDao.show();

        //让容器手动关闭，否则代码执行完毕容器自动关闭，来不及执行dao的销毁方法
        //ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //app.close();
    //}
    UserDao userDao;
    //通过set方法赋值
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    //通过构造方法赋值
//    public UserService(UserDao userDao) {
//        this.userDao = userDao;
//    }
    public void show() {
        userDao.show();
    }
}

dao层

package com.buka.dao;

public class UserDao {
    public void show() {
        System.out.println("userDao_show");
    }
    //声明周期方法
    //初始化方法，名字任意，在xml中声明
    public void init() {
        System.out.println("初始化");
    }
    //销毁方法
    public void destroy() {
        System.out.println("销毁");
    }
}

注解开发：

注解驱动：注解启动时使用注解的形式代替.xml配置，将繁杂的spring配置文件消除掉，简化书写

注解开发快，简洁；xml开发解耦；二者都会分情况用到

写在类上方：Controller注解写在web层，Service注解写在service层，Repository注解写在dao层，和Component注解功能相同，正确使用不同注解可以起到注释的作用方便阅读；有默认id，可以后边加括号修改；Scope注解指定单例多例

//@Component注解放在类上面相当于bean标签
@Component
public class UserService {

xml文件中配置

//引入context标签
<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

<!--    开启spring注解-->
    <context:component-scan base-package="com.buka"></context:component-scan>

写在类内部：Autowired注解(根据类型注入)，Qualifier注解(根据id注入)联合使用用于依赖注入，前者可以单独使用，后者不可单独使用；注解使用后无需set方法可直接赋值；Value注解依赖注入基本数据类型

Resource注解相当于上述两个注解的结合，不写参数根据类型注入，写参数根据id注入；缺点是jdk8版本可用，其他版本应额外导包才可使用，如下

<dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.3.2</version>
        </dependency>

写在方法上方：PostConstruct初始化方法注解，PreDestroy销毁方法注解

取代xml配置文件：

package com.buka.config;
//完全替代xml配置文件
import com.buka.dao.UserDao;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
//配置类注解
@Configuration
//开启spring注解
@ComponentScan("com.buka")
public class Config {
    //写在方法上，将返回值加载到spring容器中
    //@Bean
    //public UserDao get() {
        //return new UserDao();
    //}
}

连接池：

池思想：数据库连接池是个容器，负责分配、管理数据库连接(Connection)，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个

连接池的好处：资源重用，提升系统响应速度，避免数据库连接遗漏

常见的数据库连接池：(第三方jar包)DBCP、C3P0、Druid，实现了jdk提供的接口DataSource，Druid是阿里巴巴开源的数据库连接项目，是Java最好的连接池之一

导包：

<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.27</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

test包下文件 

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidPooledConnection;
import org.junit.Test;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class Demo1 {
    @Test
    public void pool1() throws SQLException {
        //1.创建连接池
        DruidDataSource dataSource = new DruidDataSource();
        //2.写参数
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/yqh");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

        dataSource.setInitialSize(10);//初始化连接个数
        dataSource.setMaxActive(50);//最大连接个数
        dataSource.setMaxWait(3000);//等待最大时长，毫秒
        //3.获取连接
        DruidPooledConnection connection = dataSource.getConnection();
        PreparedStatement pr = connection.prepareStatement("select * from user");
        ResultSet re = pr.executeQuery();
        while (re.next()) {
            System.out.println(re.getString("username"));
        }
        //4.关流，归还连接对象
        connection.close();
    }
}

配置文件法：

.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">
<!--连接池加入spring容器-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/mydb"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
<!--    service-->
    <bean class="com.buka.service.UserService" id="userService">
<!--        依赖注入-->
        <property name="userDao" ref="userDao"></property>
    </bean>
<!--    dao-->
    <bean class="com.buka.dao.UserDao" id="userDao">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>

三层架构

package com.buka.web;

import com.buka.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserWeb {
    public static void main(String[] args) {
        //创建spring容器
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //调用service
        UserService userService = (UserService) app.getBean("userService");
        //使用service的方法
        userService.add("李四","123");

    }
}




package com.buka.service;

import com.buka.dao.UserDao;

public class UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void add(String name,String pass) {
        userDao.add(name,pass);
    }
}




package com.buka.dao;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidPooledConnection;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class UserDao {
    private DruidDataSource dataSource;
    public void setDataSource(DruidDataSource dataSource) {
        this.dataSource = dataSource;
    }
    public void add(String name,String pass) {
        DruidPooledConnection connection = null;
        PreparedStatement pr = null;
        ResultSet re = null;
        try {
            connection = dataSource.getConnection();
            pr = connection.prepareStatement("insert into users(userName,userPass) values(?,?)");
            pr.setString(1,name);
            pr.setString(2,pass);
            int i = pr.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                if(re != null) {
                    re.close();
                }
                if(pr != null) {
                    pr.close();
                }
                if(connection != null) {
                    connection.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

全注解法：

.properties配置文件

#??,??????????????
#?????
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydb
#username=root????????username???????
user_name=root
password=root

配置类

package com.buka.util;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration//配置类
@ComponentScan("com.buka")//注解扫描
@PropertySource("jdbc.properties")//作用等同于<context:property-placeholder location="jdbc.properties"></context:property-placeholder>
public class SpringConfig {
    @Value("${driverClassName}")//将连接地址赋给变量，然后用成员变量set
    String Dru;
    @Value("${url}")
    String url;
    @Value("${user_name}")
    String username;
    @Value("${password}")
    String password;

    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource dataSource = new DruidDataSource();

        dataSource.setDriverClassName(Dru);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

三层架构

package com.buka.web;

import com.buka.service.OrderService;
import com.buka.util.SpringConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Controller;

@Controller
public class OrderWeb {
    public static void main(String[] args) {
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
        OrderService orderService = (OrderService) app.getBean("orderService");
        orderService.add("马六","789");
    }
}




package com.buka.service;

import com.buka.dao.OrderDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
    @Autowired
    OrderDao orderDao;

    public void add(String name, String pass) {
        orderDao.add(name,pass);
    }
}




package com.buka.dao;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidPooledConnection;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

@Repository
public class OrderDao {
    @Autowired
    DruidDataSource dataSource;

    public void add(String name, String pass) {
        DruidPooledConnection connection = null;
        PreparedStatement pr = null;
        ResultSet re = null;
        try {
            connection = dataSource.getConnection();
            pr = connection.prepareStatement("insert into users(userName,userPass) values(?,?)");
            pr.setString(1,name);
            pr.setString(2,pass);
            int i = pr.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                if(re != null) {
                    re.close();
                }
                if(pr != null) {
                    pr.close();
                }
                if(connection != null) {
                    connection.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

AOP面向切面：

AOP是面向对象的补充，不修改代码对方法进行增强(可批量)AOP底层是通过动态代理实现的，将jdk基于接口代理和cjlib基于继承代理都进行了封装

优势：提高代码复用性；业务代码编码更简洁；业务代码维护更高效；业务功能扩展更便捷

专业术语：

 导包：

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.23</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>

配置文件法：

接口：

package com.buka.aop;

public interface TargetInterface {
    void method1();
    void method2();
    void method3();

}

目标方法：

package com.buka.aop;

public class Target implements TargetInterface{
    @Override
    public void method1() {
        System.out.println("目标方法一执行");
        //用异常触发异常通知
        //int a = 10 / 0;
    }

    @Override
    public void method2() {
        System.out.println("目标方法二执行");
    }

    @Override
    public void method3() {
        System.out.println("目标方法三执行");
    }

}

增强方法：

package com.buka.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspect {
    public void before1() {
        System.out.println("前置通知一执行");
    }
    public void before2() {
        System.out.println("前置通知二执行");
    }
    public void before3() {
        System.out.println("前置通知三执行");
    }
    public void returning() {
        System.out.println("后置通知执行");
    }
    public void throwing() {
        System.out.println("异常通知执行");
    }
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕通知(前)执行");

        //分割
        Object ret = pjp.proceed();

        System.out.println("环绕通知(后)执行");
    }
    public void after() {
        System.out.println("最终通知执行");
    }
}

.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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

<!--    增强类-->
    <bean class="com.buka.aop.MyAspect" id="myAspect"></bean>
<!--    目标类-->
    <bean class="com.buka.aop.Target" id="target"></bean>
<!--    织入-->
    <aop:config>
        <aop:aspect ref="myAspect">
<!--            可以对一个常用的切点表达式进行抽取-->
            <aop:pointcut id="m1" expression="execution(public void com.buka.aop.Target.method1())"/>
<!--            before是目标方法，public void com.buka.aop.Target.method()是切点表达式，public可省略，
用*替代返回值类型(void)对任意返回值类型增强，用*(参数数据类型，可以无参)代替方法名(method())对所有该类型(类型用..代替表示全部类型)方法增强，用*代替类名(Target)对所有类进行增强，用*代替包名(aop)，对所有包增强-->
<!--            前置通知-->
<!--            method1使用抽取的切点表达式，method2和method3用常规写法-->
            <aop:before method="before1" pointcut-ref="m1"></aop:before>
            <aop:before method="before2" pointcut="execution(public void com.buka.aop.Target.method2())"></aop:before>
            <aop:before method="before3" pointcut="execution(public void com.buka.aop.Target.method3())"></aop:before>
<!--            后置通知-->
            <aop:after-returning method="returning" pointcut-ref="m1"></aop:after-returning>
<!--            异常通知-->
            <aop:after-throwing method="throwing" pointcut-ref="m1"></aop:after-throwing>
<!--            环绕通知(前后各一次)-->
            <aop:around method="around" pointcut-ref="m1"></aop:around>
<!--            最终通知-->
            <aop:after method="after" pointcut-ref="m1"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

调用：

package com.buka.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //先判断目标类有没有接口，有接口用jdk代理，用TargetInterface，没有接口用cjlib代理，用Target
        TargetInterface target = (TargetInterface) app.getBean("target");
        //调用
        target.method1();
        //target.method2();
        //target.method3();
    }
}

 配置文件+注解法：

目标方法：

package com.buka.aop;

import org.springframework.stereotype.Component;

@Component
public class Target {
    public void method1() {
        System.out.println("目标方法一执行");
    }
    public void method2() {
        System.out.println("目标方法二执行");
    }
    public void method3() {
        System.out.println("目标方法三执行");
    }
}

 增强方法：

package com.buka.aop;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect//指定这是增强类
public class MyAspect {
    //前置通知
    //@Before("execution(* com.buka.aop.Target.method())")
    //后置通知
    //@AfterReturning("execution(* com.buka.aop.Target.method())")
    //异常通知
    //@AfterThrowing("execution(* com.buka.aop.Target.method())")
    //环绕通知,方法的参数和分割同xml方式
    //@Around("execution(* com.buka.aop.Target.method())")
    //最终通知
    //使用抽取的切点表达式("MyAspect.myPoint()")
    @After("execution(* com.buka.aop.Target.method1())")
    public void before1() {
        System.out.println("增强方法一执行");
    }
    @After("execution(* com.buka.aop.Target.method2())")
    public void before2() {
        System.out.println("增强方法二执行");
    }
    @After("execution(* com.buka.aop.Target.method3())")
    public void before3() {
        System.out.println("增强方法三执行");
    }
    //抽取切点表达式
//    @Pointcut("execution(* com.buka.aop.Target.method())")
//    public void myPoint() {
//
//    }
}

 调用：

package com.buka.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        Target target = (Target) app.getBean("target");
        target.method1();
        target.method2();
        target.method3();
    }
}

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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.buka"></context:component-scan>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

通知执行顺序：同名按编写顺序，不同名如下

Spring事务：

spring事务：编程式事务(已经被淘汰)；声明式事务(常用)

编程式事务：

利用try-catch实现，缺点：代码量大，不利于维护

1.导包 2..xml 3.连接池 4.指定事务管理器 5.指定dao框架

声明式事务：

基于aop实现，有点：代码量小，便于维护

xml：

1.导包 2.连接池 3.事务管理器 4.dao框架 5.写增强方法(事务的开启、提交、回滚) 6.织入

xml+注解 事务加在service层 事务只能回滚sql操作

1.导包 2.连接池 3.事务管理器 4.dao框架 5.开启事务的注解 6.方法上加注解 @Transactional

传播行为：两个事务同时存在时的解决办法，七种传播行为对应七种规则

回滚规则：默认只回滚运行时异常，不回滚编译时异常，需要手动修改

SpringMVC:

SpringMVC是一种基于Java实现的MVC设计模式的请求驱动类型的轻量级Web框架

SpringMVC入门步骤：

建web项目

导包

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
    </dependency>
  </dependencies>

写web.xml配置文件

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

<!--  前端控制器-->
  <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:spring.mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

写spring_mvc配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.buka.web"></context:component-scan>
</beans>

接收请求资源

package com.buka.web;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class UserWeb {
    @RequestMapping("/res1")
    public void res() {
        System.out.println("接收到请求");
    }
}

响应：

package com.buka.web;

import com.buka.po.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.ArrayList;
import java.util.List;

@Controller
public class UserWeb {
    //响应页面 jsp文件在webapp下 直接return相当于请求转发
    @RequestMapping("/resp1")
    public String resp1() {
        return "hello.jsp";
    }
    //响应页面+数据 jsp在webapp下其他包下
    @RequestMapping("/resp2")
    public String resp2(Model model) {
        model.addAttribute("name","zhangsan");
        return "/jsp/hello.jsp";
    }
    //用视图解析器拼接前缀和后缀
    @RequestMapping("/resp3")
    public String resp3() {
        return "hello";
    }
    //重定向
    @RequestMapping("/resp4")
    public String resp4() {
        return "redirect:https://www.baidu.com";
    }
    //直接返回数据，不找页面
    @RequestMapping("/resp5")
    @ResponseBody
    public String resp5() {
        return "ok";
    }
    //用JSON响应json数据
//    @RequestMapping("/resp6")
//    @ResponseBody
//    public String resp6() {
//        User user = new User();
//        user.setName("zhangsan");
//        user.setAge(22);
//        String s = JSON.toJSONString(user);
//        return s;
//    }
    //响应json格式对象
    @RequestMapping("/resp7")
    @ResponseBody
    public User resp7() {
        User user = new User();
        user.setName("zhangsan");
        user.setAge(22);
        return user;
    }
    //响应json格式集合
    @RequestMapping("/resp8")
    @ResponseBody
    public List<User> resp8() {
        User user1 = new User();
        user1.setName("zhangsan");
        user1.setAge(22);
        
        User user2 = new User();
        user2.setName("lisi");
        user2.setAge(21);
        
        User user3 = new User();
        user3.setName("wangwu");
        user3.setAge(23);
        
        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        
        return list;
    }
}

导包：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>sprintMVC_demo2</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>sprintMVC_demo2 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.13.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.13.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.13.0</version>
    </dependency>
  </dependencies>

</project>

 jsp页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@page isELIgnored="false" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>hello world ${name}</h1>
</body>
</html>

spring-mvc.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com.buka"></context:component-scan>
<!--    视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
<!--    开启默认处理器适配器和解析器-->
    <mvc:annotation-driven></mvc:annotation-driven>
</beans>

 请求：

package com.buka.web;

import com.buka.po.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.Arrays;

@Controller
public class OrderWeb {
    //接收单个参数 形参要和地址栏键对应，如http://localhost:8080/sprintMVC_demo2/req1?name=zhangsan
    @RequestMapping("/req1")
    //没有返回值必须加@ResponseBody
    @ResponseBody
    public void req1(String name) {
        System.out.println(name);
    }
    //接收多个参数 同理
    @RequestMapping("/req2")
    @ResponseBody
    public void req2(String name, int age, String sex) {
        System.out.println(name + age + sex);
    }
    //接收数组,如http://localhost:8080/sprintMVC_demo2/req3?hobby=足球&hobby=篮球
    @RequestMapping("/req3")
    @ResponseBody
    public void req3(String[] hobby) {
        System.out.println(Arrays.toString(hobby));
    }
    //封装对象 对象的属性和键对应，如http://localhost:8080/sprintMVC_demo2/req4?name=z3&age=22
    @RequestMapping("/req4")
    @ResponseBody
    public void req4(User user) {
        System.out.println(user.toString());
    }
}

 接收json类型数据：

前端页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="js/axios-0.18.0.js"></script>
    <script>
        function fun() {
            //发送json类型数据
            axios({
                url:"http://localhost:8080/springMVC_demo3/req1",
                method:"post",
                data:[{name:"张三",age:20},{name:"李四",age:22},{name:"王五",age:21}]
            }).then(resp=>{

            })
        }
    </script>
</head>
<body>
<button onclick="fun()">发送ajax</button>
</body>
</html>

后端接收

@RequestMapping("/req1")
    @ResponseBody
    //根据传入数据不同灵活改变形参类型接收
    public void req1(@RequestBody List<User> list) {
        System.out.println(list);
    }

    @RequestMapping("/req2")
    @ResponseBody
    //@RequestParam解决前后端参数名称不同,使用该注解必须传参数，不传则需要required=false,defaltValue是默认值
    public void req2(@RequestParam(value="username",required = false,defaultValue = "aaa") String name) {
        System.out.println(name);
    }

spring-mvc配置文件增加内容

<!--    不再拦截静态资源-->
    <mvc:default-servlet-handler></mvc:default-servlet-handler>

web.xml增添内容

<!--  中文过滤器，解决中文乱码-->
  <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>
<servlet-mapping>
  <servlet-name>characterEncodingFilter</servlet-name>
  <url-pattern>/*</url-pattern>
</servlet-mapping>

接收文件：

导包增添

<dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.6</version>
    </dependency>
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.2.2</version>
    </dependency>

前端页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<!--enctype="multipart/form-data" 表示传入字节流-->
<form action="http://localhost:8080/springMVC_demo3/req3" method="post" enctype="multipart/form-data">
    <input type="file" name="file1">
    <input type="submit" value="提交">
</form>
</body>
</html>

后端接收

    @RequestMapping("/req3")
    @ResponseBody
    public void req3(MultipartFile file1) throws IOException {
        //文件名
        System.out.println(file1.getOriginalFilename());
        //保存
        file1.transferTo(new File("D:\\图片.png"));
    }

spring-mvc增添内容

<!--    文件上传-->
    <bean class="org.springframework.web.multipart.commons.CommonsMultipartResolver" id="multipartResolver">
<!--     限制总文件大小 字节数 -->
        <property name="maxUploadSize" value="50000000"></property>
<!--     单个文件大小-->
        <property name="maxUploadSizePerFile" value="30000000"></property>
<!--     编码集   -->
        <property name="defaultEncoding" value="UTF-8"></property>
    </bean>

其他内容： 

Restful风格：

@Controller
public class RestfulWeb {
    //传统方式请求：post、get   Restful风格请求：post(增)、get(查)、put(改)、delete(删)  传参不用key-value格式，用/直接接参数，多用于移动端开发
    //Restful风格接收参数，GetMapping、PostMapping等注解只能接收对应请求。
    @GetMapping("/req6/{name}/{age}")
    @ResponseBody
    public void req6(@PathVariable(value = "name")String name,@PathVariable(value = "age")int age) {
        System.out.println(name+age);
    }
}

类型转换器：

接收时间类型

    @RequestMapping("/req7")
    @ResponseBody
    public void req7(Date date) {
        System.out.println(date);
    }

 修改格式

package com.buka.util;

import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

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

配置类型转换器

    <!--    开启默认处理器适配器和解析器-->
    <mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-driven>



<!--    配置类型转换器-->
    <bean class="org.springframework.context.support.ConversionServiceFactoryBean" id="conversionService">
        <property name="converters">
            <list>
                <bean class="com.buka.util.DateConverter"></bean>
            </list>
        </property>
    </bean>

全局异常处理器：

作用：当程序报错时跳转到指定页面

分为简单异常处理器和自定义异常处理器，这里只介绍简单异常处理器

配置异常处理器

<!--    配置异常处理器-->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver" id="exceptionResolver">
        <property name="exceptionMappings">
            <map>
                <entry key="java.lang.Exception" value="error"></entry>
            </map>
        </property>
    </bean>

 异常程序

    @RequestMapping("/req8")
    @ResponseBody
    public void req8(String name) {
        int a = 10/0;
        System.out.println(name);
    }

前端页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>服务器走丢了，请刷新试试</h1>
</body>
</html>

拦截器：

配置拦截器

    <bean class="com.buka.util.MyInterceptor1" id="myInterceptor1"></bean>
<!--    拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
<!--            拦截哪些-->
            <mvc:mapping path="/*"/>
<!--            放行哪些-->
            <mvc:exclude-mapping path="/req9"/>
            <ref bean="myInterceptor1"></ref>
        </mvc:interceptor>
    </mvc:interceptors>

拦截器类

package com.buka.util;


import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor1 implements HandlerInterceptor {
    //在目标资源前拦截 true:放行 false:拦截
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        //访问必须携带name参数且值必须为123
        String name = request.getParameter("name");
        if("123".equals(name)) {
            return true;
        }else {
            return false;
        }
    }
    //目标资源后拦截
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        System.out.println(2);
    }
    //响应前拦截
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception) {
        System.out.println(3);
    }
}

接收请求

    @RequestMapping("/req9")
    @ResponseBody
    public void req9(String name) {
        System.out.println(name);
    }

Spring和SpringMVC整合：

 @Autowired
    UserService userService;

    @RequestMapping("/req10")
    @ResponseBody
    public void req10() {
        System.out.println("web");
        userService.show();
    }

spring-applicationContext.xml ，开启注解扫描，除了web层

    <context:component-scan base-package="com.buka">
<!--        开启注解扫描，除了Contraller，防止多余的扫描浪费时间，解耦-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

spring-mvc.xml，只开启web层注解扫描

<context:component-scan base-package="com.buka.web"></context:component-scan>

MyBatis：

原始JDBC的问题：代码冗余，封装麻烦，sql语句和java代码耦合

MyBatis官网地址：https://mybatis.org/mybatis-3/，内含入门教程

MyBatis快速入门：

导包：

<dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
    </dependencies>

准备数据库(自备)

准备实体类：

 

 

mybatis配置文件：

<?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="dev">
        <environment id="dev">
<!--            连接技术-->
            <transactionManager type="JDBC"></transactionManager>
<!--            连接池技术-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/UserMapper.xml"></mapper>
    </mappers>
</configuration>

映射文件：

<?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="userMapper">
    <!--   id为sql语句的名字  resultType返回值类型-->
<!--   查询用select标签，其他同理-->
    <select id="selAll" resultType="com.buka.po.User">
        select * from user
    </select>
<!--   parameterType输入值类型 -->
    <insert id="addUser" parameterType="com.buka.po.User">
-- mybatis表达式，接收参数
        insert into user values(#{id},#{username},#{password})
    </insert>
    <update id="upUser" parameterType="com.buka.po.User">
        update user set username=#{username} where id=#{id}
    </update>
    <delete id="delUser" parameterType="java.lang.Integer">
-- 删除通常不通过对象删除
        delete from user where id=#{id}
    </delete>
</mapper>

执行：

package com.buka.dao;

import com.buka.po.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import sun.rmi.server.UnicastServerRef;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

//增删改有事务，需要手动提交，查询没有
public class UserDao {
    public static void main(String[] args) throws IOException {
//        text1();
//        text2();
//        text3();
//        text4();
        text5();
    }

    public static void text1() throws IOException{
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行sql语  查询
        List<User> userList =sqlSession.selectList("userMapper.selAll");
        //打印结果
        System.out.println(userList);
        //释放资源
        sqlSession.close();
    }

    public static void text2() throws IOException{
        User user = new User();
        user.setId(4);
        user.setUsername("刘备");
        user.setPassword("123");

        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行sql语句，插入
        sqlSession.insert("userMapper.addUser",user);
        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }

    public static void text3() throws IOException{
        User user = new User();
        user.setId(1);
        user.setUsername("董卓");

        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行sql语句，修改
        sqlSession.update("userMapper.upUser",user);
        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }

    public static void text4() throws IOException{
        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行sql语句，删除
        sqlSession.delete("userMapper.delUser",4);
        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }

    public static void text5() throws IOException{
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行sql语  接收对应的返回类型
        User user = sqlSession.selectOne("userMapper.selById",2);
        //打印结果
        System.out.println(user);
        //释放资源
        sqlSession.close();
    }
}

起别名：

写在mybatis配置文件中，别名不能重复

<configuration>
<!--    起别名-->
    <typeAliases>
        <typeAlias type="com.buka.po.User" alias="user"></typeAlias>
    </typeAliases>
<!--    环境，可以配置多个-->
    <environments default="dev">
        <environment id="dev">
<!--            连接技术-->
            <transactionManager type="JDBC"></transactionManager>
<!--            连接池技术-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/UserMapper.xml"></mapper>
    </mappers>
</configuration>

代理开发模式：

主流开发模式，可以使用注解

service层：

package com.buka.service;

import com.buka.dao.UserDao;
import com.buka.po.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class UserService {
    public static void main(String[] args) throws IOException {
//        text1();
//        text2();
//        text3();
//        text4();
//        text5();
        text6();
    }
    public static void text1() throws IOException{
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取dao对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        List<User> user = userDao.selAll();
        System.out.println(user);
        sqlSession.close();
    }

    public static void text2() throws IOException{
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取dao对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        User user = userDao.selById(1);
        System.out.println(user);
        sqlSession.close();
    }

    public static void text3() throws IOException{
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取dao对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        User user = new User();
        user.setId(4);
        user.setUsername("马超");
        user.setPassword("987");
        userDao.addUser(user);
        sqlSession.commit();
        sqlSession.close();
    }

    public static void text4() throws IOException{
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取dao对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        User user = new User();
        user.setId(4);
        user.setUsername("赵云");
        userDao.upUser(user);
        sqlSession.commit();
        sqlSession.close();
    }

    public static void text5() throws IOException{
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取dao对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        User user = new User();
        userDao.delUser(4);
        sqlSession.commit();
        sqlSession.close();
    }

}

dao层接口：

package com.buka.dao;

import com.buka.po.User;

import java.util.List;

public interface UserDao {
    List<User> selAll();
    User selById(int id);
    void addUser(User user);
    void upUser(User user);
    void delUser(int id);


}

映射文件：

<?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.buka.dao.UserDao">
    <!--   id为sql语句的名字  resultType返回值类型   用接口必须和方法名一致，返回值和输入值必须和方法泛型一致-->
<!--   查询用select标签，其他同理-->
    <select id="selAll" resultType="user">
        select * from user
    </select>
<!--   parameterType输入值类型 -->
    <insert id="addUser" parameterType="user">
-- mybatis表达式，接收参数
        insert into user values(#{id},#{username},#{password})
    </insert>
    <update id="upUser" parameterType="user">
        update user set username=#{username} where id=#{id}
    </update>
    <delete id="delUser" parameterType="int">
-- 删除通常不通过对象删除
        delete from user where id=#{id}
    </delete>
    <select id="selById" parameterType="int" resultType="user">
        select * from user where id=#{id}
    </select>

</mapper>

动态sql：

这里介绍常用的两种

if分支：

service层：

//    条件查询
    public static void text6() throws IOException{
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取dao对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        User user = new User();
        user.setId(2);
//        user.setUsername("孙尚香");
//        user.setPassword("456");
        List<User> selBy = userDao.selBy(user);
        System.out.println(selBy);
        sqlSession.close();
    }

dao层接口：

    //条件查询
    List<User> selBy(User user);

映射文件：

<!--    动态查询-->
    <select id="selBy" parameterType="user" resultType="user">
        select * from user
        <where>
            <if test="id!=0">
                and id=#{id}
            </if>
            <if test="username!=null">
                and username=#{username}
            </if>
            <if test="password!=null">
                and password=#{password}
            </if>
        </where>
    </select>

foreach遍历：

service层：

    //批量删除
    public static void text7() throws IOException{
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取dao对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);

        List<Integer> arr = new ArrayList<>();
        arr.add(1);
        arr.add(2);
        arr.add(3);
        userDao.del(arr);
        sqlSession.commit();
        sqlSession.close();
    }

dao层接口：

    //批量删除
    void del(List<Integer> arr);

映射文件：

<!--    批量删除-->
    <delete id="del" parameterType="list">
        delete from user
    <where>
--      foreach标签遍历 类型         前缀            后缀      临时变量      分隔符
        <foreach collection="list" open="id in (" close=")" item="id" separator=",">
            #{id}
        </foreach>
    </where>
    </delete>

其他内容：

平铺映射：

解决数据库中子段名和实体类中属性名不同

<!--    平铺映射-->
    <resultMap id="user_ext" type="user">
<!--     id主键  result普通字段   property实体类中字段名  column数据库中字段名   -->
        <id property="id" column="id"></id>
        <result property="userName" column="user_name"></result>
        <result property="passWord" column="pass_word"></result>
    </resultMap>
    <select id="selAll" resultMap="user_ext">
        select * from user
    </select>

多表查询：

<!--    利用平铺映射实现多表查询-->
<!--    平铺映射写法一-->
    <resultMap id="user_order" type="order">
        <id column="id" property="id"></id>
        <result column="name" property="name"></result>
        <result column="u_id" property="user.id"></result>
        <result column="user_name" property="user.userName"></result>
        <result column="pass_word" property="user.passWord"></result>
    </resultMap>
<!--    平铺映射写法二-->
    <resultMap id="user_order" type="order">
        <id column="id" property="id"></id>
        <result column="name" property="name"></result>
        <association property="user" javaType="com.buka.po.User">
            <result column="u_id" property="id"></result>
            <result column="user_name" property="userName"></result>
            <result column="pass_word" property="passWord"></result>
        </association>
    </resultMap>

    <select id="sel_user_order" resultMap="user_order">
        select * from order join user on order.u_id=user.id
    </select>

层叠映射：

新建类继承实体类并封装：

package com.buka.po;

import java.util.List;

public class UserExt extends User{
    private List<Order> orderList;

    public List<Order> getOrderList() {
        return orderList;
    }

    public void setOrderList(List<Order> orderList) {
        this.orderList = orderList;
    }
}

映射文件：

<!--    层叠映射-->
    <resultMap id="user_orderlist" type="com.buka.po.UserExt">
        <id property="id" column="id"></id>
        <result property="userName" column="user_name"></result>
        <result property="passWord" column="pass_word"></result>
<!--                  集合名字               集合泛型-->
        <collection property="orderList" ofType="com.buka.po.Order">
            <id property="id" column="id(1)"></id>
            <result property="name" column="name"></result>
        </collection>
    </resultMap>

<select id="sel_user_listOrder" resultMap="user_orderlist">
    select * from user join order on order.u_id=user.id
</select>

注解开发：

开发时是xml和注解是并行的，简单的sql语句可以用注解，复杂的可以用xml

接口：
 

    @Select("select * from user")
    List<User> sel_all();

    @Select("select * from user where id=#{id}")
    User sel_id(int id);

    @Delete("delete from user where id=#{id}")
    void del(int id);

    //@Update(""),@Insert("")同理


    //多表查询
    @Select("select * from `order` join user on `order`.u_id=user.id")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(property = "user",//对象名
                    column = "u_id",//发送字段传给selById
                    javaType = User.class,//对象类型
                    one = @One(select = "com.buka.dao.UserDao.selById"))
    })
    List<Order> sel_order_user();
    @Select("select * from user where id=#{id}")
    User selById(int id);//对象传回 property = "user"

    //一对多查询
    @Select("select * from user join `order` on `order`.u_id=user.id")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "user_name",property = "userName"),
            @Result(column = "pass_word",property = "passWord"),
            @Result(property = "orderList",
                    javaType = List.class,
                    column = "id",
                    many = @Many(select = "com.buka.dao.UserDao.selOrder"))
    })
    List<UserExt> USER_EXTS();
    @Select("select * from `order` where u_id=#{id}")
    List<Order> selOrder(int id);

配置文件：

    <mappers>
<!--        关联-->
<!--        <mapper resource="mapper/UserMapper.xml"></mapper>-->
<!--        开启注解-->
        <package name="com.buka.dao"/>
    </mappers>

文书华
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SSM框架：spring+springMVC+Mybatis
m0_62145574的博客
11-24 3181
1.什么是SSM框架： SSM框架是Spring MVC ，Spring和Mybatis框架的整合，是标准的MVC模式，将整个系统划分为View层，Controller层，Service层，DAO层四层，使用Spring MVC负责请求的转发和视图管理，Spring实现业务对象管理，Mybatis作为数据对象的持久化引擎。 2.SSM框架各层的关系: DAO层、Service层这两个层次都可以单独开发，互相的耦合度很低，完全可以独立进行，这样的一种模式在开发大项目的过程中尤其有优势。 Contr
SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）
热门推荐
在路上
07-19 63万+
使用SSM（Spring、SpringMVC和Mybatis）已经有三个多月了，项目在技术上已经没有什么难点了，基于现有的技术就可以实现想要的功能，当然肯定有很多可以改进的地方。之前没有记录SSM整合的过程，这次刚刚好基于自己的一个小项目重新搭建了一次，而且比项目搭建的要更好一些。以前解决问题的过程和方法并没有及时记录，以后在自己的小项目中遇到我再整理分享一下。这次，先说说三大框架整合过程。个人认
手把手教你整合最优雅SSM框架：SpringMVC + Spring + MyBatis
小疯的代码健身房
05-08 61万+
小疯手把手带你整合SpringMVC+Spring+MyBatis三大框架，俗称SSM，用它完全代替传统的SSH框架，把它们最优雅的一面发挥出来。整合配置结束后，会有一个应用实例“图书管理系统”带给大家，希望能快速上手这个框架！
【SSM进阶学习系列丨整合篇】Spring+SpringMVC+MyBatis 框架配置详解
陈橘又青的博客
04-26 1万+
MyBatis框架和Spring框架整合需要一个mybatis-spring的jar包，该jar包的作用是两个框架的转换包。
SpringMVC框架+spring框架+Mybatis框架（SSM框架整合）
weixin_61491281的博客
06-25 1574
1.1原始方法整合 1.准备工作 2.创建Maven项目
Spring | SSM整合（SpringMVC+Spring+MyBatis）
鷾
01-19 1407
SSM整合（SpringMVC+Spring+MyBatis），使用maven构建工具开发，mysql作为数据库，Druid作为数据库连接池，better-mybatis-generator插件自动生成dao、pojo类
SSM框架SpringMVC+ Spring + MyBatis介绍
小石潭记丶
05-10 1992
手把手教你整合最优雅SSM框架：SpringMVC + Spring + MyBatis
【SSM整合】SpringMVC + Spring + Mybatis整合详细教程_springmvc+mybatis
2401_84584817的博客
05-12 658
<resource><includes><resource><includes>
SSM框架整合大揭秘：Spring+SpringMVC+MyBatis配置详解与实战
qq_44103359的博客
04-28 993
Spring：Spring是一个开源的企业级Java应用框架，它提供了IoC（控制反转）和AOP（面向切面编程）等特性，可以简化Java企业应用的开发。SpringMVC：SpringMVC是Spring框架的一个模块，用于处理Web请求和响应。它是一个轻量级的、简洁的Web框架，可以与Spring无缝集成。MyBatis：MyBatis是一个持久层框架，它通过SQL映射文件将Java对象与数据库表中的记录进行映射，简化了数据库操作。
SSM框架SpringMVC+ Spring + MyBatis实现
小石潭记丶
05-16 569
1.SSM框架SpringMVC+ Spring + MyBatis介绍 (如果对ssm框架不熟的朋友，相关知识可以参考该博文查看0.0) 2.SSM项目的创建
wcdog:SSM（Spring + SpringMVC + Mybatis）新闻管理系统
03-11
JaveWeb迷你新闻发布系统基于SSM架构迷你新闻发布系统，包含前端，尺寸，移动端三端应用。介绍1.移动端应用（Android wcdog-app） MVP +材料+改造2+接收戳这里2.web前端项目（wcdog-web） vue + vuex + vue路由器+ ...
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
SSM框架SpringMVC + Spring + MyBatis.zip
12-29
这个压缩包"SSM框架SpringMVC + Spring + MyBatis.zip"包含了基于这三个框架的项目实例，为开发者提供了学习和实践SSM整合的一个实际操作平台。 首先，让我们深入理解一下SSM框架的每一个组成部分： 1. **Spring ...
ssm:Spring+SpringMVC + MyBatis
05-14
ssm使用SpringMVC和MyBatis搭建的java项目框架，用于学习与快速构建新项目。包含内容：Spring集成mvcSpring集成MyBatismybatis generatorRedis客户端配置与缓存实现rocketMQ客户端配置Kafka客户端配置部署与运行步骤...
配置Java开发环境
Broken_x的博客
07-10 1576
Java开发环境配置
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 283
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
elk部署springboot
Chihirozy的博客
07-11 393
elk部署springboot。
基于Java技术的校园台球厅人员与设备管理系统
最新发布
heye0910032的博客
07-12 534
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。
SSM框架-详细整合教程(Spring+SpringMVC+MyBatis).docx
11-13
"这篇文档是关于SSM框架的详细整合教程，主要涵盖了Spring、SpringMVC和MyBatis这三个组件的集成与应用。作者强调理解框架的思想对于提升编程能力的重要性，同时提供了实践中的整合步骤。" SSM框架是Java开发中广泛...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值