MyBatis 实现基本CRUD操作

曾经终败给现在 2022-02-23 02:38 337阅读 0赞

[https://blog.csdn.net/xnh\_565175944/article/details/89050122][https_blog.csdn.net_xnh_565175944_article_details_89050122]

基本了解和使用可以看上面的博客

### **基于代理Dao实现CRUD操作，首先我们要先明白几点配置文件的常规使用要求:** ###

1、持久层接口和持久层接口的映射配置必须在相同的包下

2、持久层映射配置中 mapper 标签的 namespace 属性取值必须是持久层接口的全限定类名

3、SQL 语句的配置标签<select>,<insert>,<delete>,<update>的 id 属性必须和持久层接口的 方法名相同。

### **我们对映射配置文件中配置的时候，要了解几种标签和属性：** ###

**resultType 属性：** 用于指定结果集的类型。

**parameterType 属性：** 用于指定传入参数的类型。

**sql 语句中使用\#\{\}字符：** 它代表占位符，相当于原来 jdbc 部分所学的?，都是用于执行语句时替换实际的数据。 具体的数据是由\#\{\}里面的内容决定的。

**\#\{\}中内容的写法：** 由于数据类型是基本类型，所以此处可以随意写。

**User类**

public class User implements Serializable {
    
        private Integer userId;
        private String userName;
        private String userAddress;
        private String userSex;
        private Date userBirthday;
    
        public Integer getUserId() {
            return userId;
        }
        public void setUserId(Integer userId) {
            this.userId = userId;
        }
        public String getUserName() {
            return userName;
        }
        public void setUserName(String userName) {
            this.userName = userName;
        }
        public String getUserAddress() {
            return userAddress;
        }
        public void setUserAddress(String userAddress) {
            this.userAddress = userAddress;
        }
        public String getUserSex() {
            return userSex;
        }
        public void setUserSex(String userSex) {
            this.userSex = userSex;
        }
        public Date getUserBirthday() {
            return userBirthday;
        }
        public void setUserBirthday(Date userBirthday) {
            this.userBirthday = userBirthday;
        }
        @Override
        public String toString() {
            return "User{" +
                    "userId=" + userId +
                    ", userName='" + userName + '\'' +
                    ", userAddress='" + userAddress + '\'' +
                    ", userSex='" + userSex + '\'' +
                    ", userBirthday=" + userBirthday +
                    '}';
        }
    }

**IUserDao接口**

public interface IUserDao {
        /**
         * 查询所有用户
         * @return
         */
        List<User> findAll();
        /**
         * 保存用户
         * @param user
         */
        void saveUser(User user);
        /**
         * 更新用户
         * @param user
         */
        void updateUser(User user);
        /**
         * 根据Id删除用户
         * @param userId
         */
        void deleteUser(Integer userId);
        /**
         * 根据id查询用户信息
         * @param userId
         * @return
         */
        User findById(Integer userId);
        /**
         * 根据名称模糊查询用户信息
         * @param username
         * @return
         */
        List<User> findByName(String username);
        /**
         * 查询总用户数
         * @return
         */
        int findTotal();
        
    }

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"></transactionManager>
                
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"></property>
                    <property name="url" value="jdbc:mysql://localhost:3306/eesy_mybatis"></property>
                    <property name="username" value="root"></property>
                    <property name="password" value="root"></property>
                </dataSource>
            </environment>
        </environments>
        
        <mappers>
            
            <package name="com.first.dao"></package>
        </mappers>
    </configuration>

与之前不同的是，我们把mapper标签换成了pakage标签，这样就可以扫描整个包内的dao文件了。

IUserDao.xml文件 用来指定作用的持久层接口和配置SQL语句(mapper内配置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.first.dao.IUserDao">
    
        <resultMap id="userMap" type="User">
            
            <id property="userId" column="id"></id>
            
            <result property="userName" column="username"></result>
            <result property="userAddress" column="address"></result>
            <result property="userSex" column="sex"></result>
            <result property="userBirthday" column="birthday"></result>
        </resultMap>
    
        
        <select id="findAll" resultMap="userMap">
            
            select * from user;
        </select>
    </mapper>

**这里需要注意，因为我们查询出来的结果类型和我们设置的类名不同，所以我们要将数据库中的字段与类内的成员变量对应起来，所以我们使用 resultType属性来设置返回类型。 其中 property 中的值是类内字段， column是数据库中的字段。 这样就对应起来了。**

<update id="updateUser" parameterType="USER">
        update user set username=#{userName},address=#{userAddress},sex=#{userAex},birthday=#{userBirthday} where id=#{userId}
    </update>

**这里我们更新用户，我们只需要将 update 的 id 和接口内的函数名对应，因为要传入参数，所以我们要指定parameterType的类型，传入的参数就是User。**

<delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id = #{uid}
    </delete>
        
    
    <select id="findById" parameterType="INT" resultMap="userMap">
        select * from user where id = #{uid}
    </select>
    
    
    <select id="findByName" parameterType="string" resultMap="userMap">
        select * from user where username like #{name}
    
    </select>
    
    
    <select id="findTotal" resultType="int">
        select count(id) from user;
    </select>

**这几个用法与上面类似**

<insert id="saveUser" parameterType="user">
    
        <selectKey keyProperty="userId" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(username,address,sex,birthday)values(#{userName},#{userAddress},#{userSex},#{userBirthday});
    </insert>

**获取保存在数据库中的id，可以设置selectKey标签中的keyProperty的值设置为传入的，keyColumn为数据库中的主键id，resultType为返回值类型。**

接下来只需要读取配置文件，然后测试即可。

public class MybatisTest {
    
        private InputStream in;
        private SqlSession sqlSession;
        private IUserDao userDao;
    
        @Before//用于在测试方法执行之前执行
        public void init()throws Exception{
            //1.读取配置文件，生成字节输入流
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.获取SqlSessionFactory
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
            //3.获取SqlSession对象
            sqlSession = factory.openSession();
            //4.获取dao的代理对象
            userDao = sqlSession.getMapper(IUserDao.class);
        }
    
        @After//用于在测试方法执行之后执行
        public void destroy()throws Exception{
            //提交事务
            sqlSession.commit();
            //6.释放资源
            sqlSession.close();
            in.close();
        }
    
        /**
         * 测试查询所有
         */
        @Test
        public void testFindAll(){
            //5.执行查询所有方法
            List<User> users = userDao.findAll();
            for(User user : users){
                System.out.println(user);
            }
    
        }
    
        /**
         * 测试保存操作
         */
        @Test
        public void testSave(){
            User user = new User();
            user.setUserName("modify User property");
            user.setUserAddress("北京市顺义区");
            user.setUserSex("男");
            user.setUserBirthday(new Date());
            System.out.println("保存操作之前："+user);
            //5.执行保存方法
            userDao.saveUser(user);
    
            System.out.println("保存操作之后："+user);
        }
    
        /**
         * 测试更新操作
         */
        @Test
        public void testUpdate(){
            User user = new User();
            user.setUserId(50);
            user.setUserName("mybastis update user");
            user.setUserAddress("北京市顺义区");
            user.setUserSex("女");
            user.setUserBirthday(new Date());
    
            //5.执行保存方法
            userDao.updateUser(user);
        }
    
        /**
         * 测试删除操作
         */
        @Test
        public void testDelete(){
            //5.执行删除方法
            userDao.deleteUser(48);
        }
    
        /**
         * 测试删除操作
         */
        @Test
        public void testFindOne(){
            //5.执行查询一个方法
            User  user = userDao.findById(50);
            System.out.println(user);
        }
    
        /**
         * 测试模糊查询操作
         */
        @Test
        public void testFindByName(){
            //5.执行查询一个方法
            List<User> users = userDao.findByName("%王%");
    //        List<User> users = userDao.findByName("王");
            for(User user : users){
                System.out.println(user);
            }
        }
    
        /**
         * 测试查询总记录条数
         */
        @Test
        public void testFindTotal(){
            //5.执行查询一个方法
            int count = userDao.findTotal();
            System.out.println(count);
        }
    }

测试结果省略.....

**这里我们可以明显的看出来，我们想要对数据库进行怎样的操作的时候，不用去费力写一个一个的操作类，只需要接口中定义函数，写一个标签配置一下即可。**

### Mybatis与JDBC编程的比较 ###

**1.数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。 解决： 在 SqlMapConfig.xml 中配置数据链接池，使用连接池管理数据库链接。  
  
2.Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java 代码。 解决： 将 Sql 语句配置在 XXXXmapper.xml 文件中与 java 代码分离。**

**3.向sql语句传参数麻烦，因为sql语句的where 条件不一定，可能多也可能少，占位符需要和参数对应。 解决： Mybatis自动将 java 对象映射至 sql 语句，通过 statement 中的 parameterType 定义输入参数的 类型。**

**4.对结果集解析麻烦，sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成 pojo 对 象解析比较方便。 解决： Mybatis自动将 sql执行结果映射至 java 对象，通过statement中的resultType 定义输出结果的类型**

[https_blog.csdn.net_xnh_565175944_article_details_89050122]: https://blog.csdn.net/xnh_565175944/article/details/89050122