点击去到mybatis的基本使用（单单使用mybatis操作数据库）

一、 spring（xml）整合mybatis（jdk1.8）

1. spring整合mybatis的关键在于：整合Mybatis，就是将Mybatis用到的内容交给Spring管理。（主要有两件事）
   • 第一件事是:Spring要管理MyBatis中的SqlSessionFactory（里面还需要配置实体类别名，即mybatis配置文件的typeAliases标签）。（主要用到的类：SqlSessionFactoryBean）
   • 第二件事是:Spring要管理Mapper接口的扫描。（主要用到的类：MapperScannerConfigurer）

注意：

上图sql映射文件（UserMapper.xml）的路径需要和mapper接口（UserMapper.java）的路径一样（即放在同一目录下），因为在spring配置上，使用的
 <bean id="mapper" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.knife.mapper"/>
</bean>

相当于mybatis配置文件里面的：（使用包扫描方式）
<mappers>
     <package name="com.knife.mapper"/>
 </mappers>

1. UserMapper.java（mapper接口）

public interface UserMapper {
    
    List<User> selectAllUser(); //使用xml映射文件写sql语句

//    注解的选择：当sql语句比较简单时，可以使用注解的方式编写sql语句
//    如果sql语句比较复杂就推荐使用xml映射文件（比如需要使用到动态sql语句的情况）
    @Select("select * from tb_user where id = #{id}") //通过注解直接在mapper接口上的方法上面书写sql语句（效果是一样的）
    User selectById(int id);
}

2. UserMapper.xml（sql配置文件）

<?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.knife.mapper.UserMapper">

    <select id="selectAllUser" resultType="user">
        select * from tb_user;
    </select>

</mapper>

3. User实体类

public class User {
    
    private Integer id;
    private String username;
    private String password;
    private String gender;
    private String addr;

    public Integer getId() {
    
        return id;
    }

    public void setId(Integer id) {
    
        this.id = id;
    }

    public String getUsername() {
    
        return username;
    }

    public void setUsername(String username) {
    
        this.username = username;
    }

    public String getPassword() {
    
        return password;
    }

    public void setPassword(String password) {
    
        this.password = password;
    }

    public String getGender() {
    
        return gender;
    }

    public void setGender(String gender) {
    
        this.gender = gender;
    }

    public String getAddr() {
    
        return addr;
    }

    public void setAddr(String addr) {
    
        this.addr = addr;
    }

    @Override
    public String toString() {
    
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", gender='" + gender + '\'' +
                ", addr='" + addr + '\'' +
                '}';
    }
}

4. UserService（业务层接口）

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

    User selectById(int id);
}

5. UserServiceImpl（业务层实现类）

public class UserServiceImpl implements UserService {
    

    private UserMapper userMapper;

//    提供setter方法（setter注入）
    public void setUserMapper(UserMapper userMapper) {
    
        this.userMapper = userMapper;
    }

    @Override
    public List<User> selectAllUser() {
    
        return userMapper.selectAllUser();
    }

    @Override
    public User selectById(int id) {
    
        return userMapper.selectById(id);
    }


}

6. ApplicationContext.xml（spring配置文件）

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

<!--
           1、引入properties文件，使用<context:property-placeholder>
           2、使用bean标签创建DataSource对象，并注入连接信息  相当于获取到连接  交给Spring管理
           3、使用bean标签创建SqlSessionFactory对象，注入DataSource数据 相当于底层已经创建好SqlSession对象  交给Spring管理
           4、使用bean标签创建MapperConfigurer对象，用于扫描dao包，交给Spring管理
           5、使用<context:>开启注解扫描
        -->

    <!-- 1、引入properties文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 2、使用bean标签创建DataSource对象，并注入连接信息  相当于获取到连接  交给Spring管理 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--  3、使用bean标签创建SqlSessionFactoryBean对象，注入DataSource数据 相当于底层已经创建好SqlSession对象  交给Spring管理 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--        包别名配置（相当于mybatis配置文件里面的<typeAliases>标签-->
        <property name="typeAliasesPackage" value="com.knife.pojo"/>
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--  4、使用bean标签创建MapperConfigurer对象，用于扫描dao包，交给Spring管理
    (sql文件映射，相当于mybatis配置文件里面的：
        <mappers>
             <package name="com.knife.mapper"/>
        </mappers>
    -->
    <bean id="mapper" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.knife.mapper"/>
    </bean>

<!--    配置bean-->
    <bean id="userService" class="com.knife.service.impl.UserServiceImpl">
        <property name="userMapper" ref="userMapper"/>
    </bean>

    <!--  5、使用<context:>开启注解扫描 -->
<!--    <context:component-scan base-package="com.knife"/>-->

</beans>

7. jdbc.properties(数据库四要数)

jdbc.driver= com.mysql.cj.jdbc.Driver
jdbc.url =jdbc:mysql://localhost:3306/mybatis?useSSL=false&serverTimeZone=UTC&allowPublicKeyRetrieval=true
jdbc.username = root
jdbc.password = dadao

8. springTest（测试类）

/**
 * 注意:这里是spring注解开发整合mybatis的(mybatis-config.xml文件是没有用处的)
 */
public class springTest {
    
    public static void main(String[] args) {
    
 //创建Spring工厂类，传入的参数是Spring核心配置文件
        ApplicationContext applicationContext = new
                ClassPathXmlApplicationContext("applicationContext.xml");

        //获取UserService接口的实现类，使用UserService接口接收
        UserService bean = applicationContext.getBean(UserService.class);

        List<User> users = bean.selectAllUser();
        System.out.println(users);

        User user = bean.selectById(1);
        System.out.println(user);
    }
}

需要导入的依赖（版本按照自己的修改就行）

 <dependencies>
        <!--1. 添加mybatis依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>

        <!--        mysql 依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.31</version>
        </dependency>

<!--        第三方资源：德鲁伊-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

<!--        spring依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <!--Spring操作数据库需要该jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <!--
           Spring与Mybatis整合的jar包
           这个jar包mybatis在前面，是Mybatis提供的
           -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>

    </dependencies>

二、 spring（注解）整合mybatis（jdk1.8）

注解开发与xml文件开发的不同在于：注解开发使用配置类（对象），代替了xml文件。

1. JdbcConfig.java（数据源配置类）

public class JdbcConfig {
    
    @Value("${jdbc.driver}")  //简单类型注入，即把jdbc.driver的值赋值给变量driver
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean   //告诉spring该类需要被spring管理（设置该方法的返回值作为spring管理的bean）
    public DataSource dataSource(){
    
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

2. MybatisConfig.java（mybatis配置类）

/**
 * mybatis配置类
 */
public class MyBatisConfig {
    

    @Bean   //注入引用类型数据，可以通过参数的方式进行传递（spring底层会自动帮你注入）
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
    
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        //设置模型类的别名扫描（即<typeAliases>标签）
        factoryBean.setTypeAliasesPackage("com.knife.pojo");
        //设置数据源（即数据库的配置：数据源来自jdbcConfig类，需要把该类设置给spring管理，然后通过参数传递）
        factoryBean.setDataSource(dataSource);

        return factoryBean;
    }

    //定义bean，返回MapperScannerConfigurer对象

    /**
     * 映射sql文件
     *
     * 作用相当于
     *   <mappers>
     *        <package name="com.knife.mapper"/>
     *    </mappers>
     * @return
     */
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
    
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.knife.mapper");
        return msc;
    }

}

3. SpringConfig.java（spring核心配置类）

spring核心配置类其实就相当于上面的ApplicationContext.xml文件，该类导入的数据，就相当于ApplicationContext.xml文件里面配置的数据

/**
 * spring的核心配置类
 */
@Configuration //声明该类为spring的核心配置类
@ComponentScan("com.knife.service") //扫描到的包下的类能够被Spring框架扫描到写在类上的注解(开启注解扫描）
@PropertySource("classpath:jdbc.properties") //用于加载指定的属性文件。通过该注解，我们可以将属性文件中的键值对加载到Spring的环境变量中，从而在程序中使用@Value注解获取属性值。
@Import({
    JdbcConfig.class,MyBatisConfig.class})   // 将JdbcConfig类导入配置类（即该类也属于配置类）
public class SpringConfig {
    

}

4. UserMapper.java（mapper接口）、User（实体类）、以及UserMapper.xml（sql映射文件）、UserService（业务层接口）以及jdbc.properties都是和上面xml方式整合mybatis的一样。

5. UserServiceImpl（业务层实现类）

@Service  //相当于@Component，表示该类被spring控制
public class UserServiceImpl implements UserService {
    

    @Autowired  //自动注入（按类型）
    private UserMapper userMapper;

    @Override
    public List<User> selectAllUser() {
    
        return userMapper.selectAllUser();
    }

    @Override
    public User selectById(int id) {
    
        return userMapper.selectById(id);
    }


}

6. SpringTest（测试类）

/**
 * 注意:这里是spring注解开发整合mybatis的(mybatis-config.xml文件是没有用处的)
 */
public class springTest {
    
    public static void main(String[] args) {
    
//       如果是使用配置文件，则使用ClassPathXmlApplicationContext获取spring容器
//        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

//        注意，因为这里使用的是spring的注解开发，所以需要使用AnnotationConfigApplicationContext获取spring容器
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService bean = context.getBean(UserService.class);

        List<User> users = bean.selectAllUser();
        System.out.println(users);

        User user = bean.selectById(1);
        System.out.println(user);
    }
}