MyBatis对表执行CRUD操作

雨点打透心脏的1/2处 2022-07-13 00:39 285阅读 0赞

一、使用MyBatis对表执行CRUD操作——基于XML的实现

1、定义sql映射xml文件

　　userMapper.xml文件的内容如下：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <!-- namespace命名空间，作用就是对sql进行分类化管理，理解sql隔离 注意：使用mapper代理方法开发，namespace有特殊重要的作用 -->
  7. <mapper namespace="com.baowei.entity.User">
  9.     <!-- 在 映射文件中配置很多sql语句 -->
  10.     <!-- 需求：通过id查询用户表的记录 -->
  11.     <!-- 通过 select执行数据库查询 id：标识 映射文件中的 sql 将sql语句封装到mappedStatement对象中，所以将id称为statement的id 
  12.         parameterType：指定输入 参数的类型，这里指定int型 #{}表示一个占位符号 #{id}：其中的id表示接收输入 的参数，参数名称就是id，如果输入 
  13.         参数是简单类型，#{}中的参数名可以任意，可以value或其它名称 resultType：指定sql输出结果 的所映射的java对象类型，select指定resultType表示将单条记录映射成的java对象。 -->
  14.     <select id="findUserById" parameterType="int" resultType="com.baowei.entity.User">
  15.         SELECT
  16.         * FROM USER WHERE id=#{value}
  17.     </select>
  19.     <!-- 根据用户名称模糊查询用户信息，可能返回多条 resultType：指定就是单条记录所映射的java对象 类型 ${}:表示拼接sql串，将接收到参数的内容不加任何修饰拼接在sql中。 
  20.         使用${}拼接sql，引起 sql注入 ${value}：接收输入 参数的内容，如果传入类型是简单类型，${}中只能使用value -->
  21.     <select id="findUserByName" parameterType="java.lang.String"
  22.         resultType="com.baowei.entity.User">
  23.         SELECT * FROM USER WHERE name LIKE '%${value}%'
  24.     </select>
  26.     <!-- 添加用户 parameterType：指定输入 参数类型是pojo（包括 用户信息） #{}中指定pojo的属性名，接收到pojo对象的属性值，mybatis通过OGNL获取对象的属性值 -->
  27.     <insert id="insertUser" parameterType="com.baowei.entity.User">
  28.         <!-- 将插入数据的主键返回，返回到user对象中 SELECT LAST_INSERT_ID()：得到刚insert进去记录的主键值，只适用与自增主键 
  29.             keyProperty：将查询到主键值设置到parameterType指定的对象的哪个属性 order：SELECT LAST_INSERT_ID()执行顺序，相对于insert语句来说它的执行顺序 
  30.             resultType：指定SELECT LAST_INSERT_ID()的结果类型 -->
  31.         <selectKey keyProperty="id" order="AFTER" resultType="int">
  32.             SELECT
  33.             LAST_INSERT_ID()
  34.         </selectKey>
  35.         insert into user(name,age)
  36.         values(#{name},#{age})
  38.     </insert>
  40.     <!-- 删除 用户 根据id删除用户，需要输入 id值 -->
  41.     <delete id="deleteUser" parameterType="java.lang.Integer">
  42.         delete from user where
  43.         id=#{id}
  44.     </delete>
  46.     <!-- 根据id更新用户 分析： 需要传入用户的id 需要传入用户的更新信息 parameterType指定user对象，包括 id和更新信息，注意：id必须存在 
  47.         #{id}：从输入 user对象中获取id属性值 -->
  48.     <update id="updateUser" parameterType="com.baowei.entity.User">
  49.         update user set
  50.         name=#{name},age=#{age}
  51.         where id=#{id}
  52.     </update>
  54. </mapper>

2、在SqlMapConfig.xml中的配置

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4. "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.     <properties resource="db.properties">
  7.     </properties>
  8.     <environments default="development">
  9.         <environment id="development">
  10.             <!-- 使用jdbc事务管理，事务控制由mybatis -->
  11.             <transactionManager type="JDBC" />
  12.             <!-- 数据库连接池，由mybatis管理 -->
  13.             <dataSource type="POOLED">
  14.                 <property name="driver" value="${jdbc.driver}" />
  15.                 <property name="url" value="${jdbc.url}" />
  16.                 <property name="username" value="${jdbc.username}" />
  17.                 <property name="password" value="${jdbc.password}" />
  18.             </dataSource>
  19.         </environment>
  20.     </environments>
  21.     <!-- 加载 映射文件 -->
  22.     <mappers>
  23.         <!-- 注册userMapper.xml文件， userMapper.xml位于com.baowei.mapping/这个包下，所以resource写成com/baowei/mapping/userMapper.xml -->
  24.         <mapper resource="com/baowei/mapping/userMapper.xml" />
  26.     </mappers>
  28. </configuration>

　　

3、单元测试类代码如下：

  1. import java.io.InputStream;
  2. import org.apache.ibatis.io.Resources;
  3. import org.apache.ibatis.session.SqlSession;
  4. import org.apache.ibatis.session.SqlSessionFactory;
  5. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  6. import org.junit.Before;
  7. import org.junit.Test;
  9. import com.baowei.entity.User;
  11. public class UserDaoXmlTest {
  13.     private SqlSession sqlSession;
  15.     @Before
  16.     public void setUp() throws Exception {
  18.         String resource = "SqlMapConfig.xml";
  19.         InputStream inputStream = Resources.getResourceAsStream(resource);
  21.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
  22.                 .build(inputStream);
  23.         sqlSession = sqlSessionFactory.openSession();
  24.     }
  26.     @Test
  27.     public void testFindUserById() throws Exception {
  28.         String statement = "com.baowei.entity.User.findUserById";// 映射sql的标识字符串
  29.         // 执行查询返回一个唯一user对象的sql
  30.         User user = sqlSession.selectOne(statement, 2);
  31.         System.out.println(user);
  32.     }
  34.     @Test
  35.     public void testfindUserByName() throws Exception {
  37.         String statement = "com.baowei.entity.User.findUserByName";// 映射sql的标识字符串
  38.         // 执行查询返回一个唯一user对象的sql
  39.         User user = sqlSession.selectOne(statement, "1111");
  40.         System.out.println(user);
  42.     }
  44.     @Test
  45.     public void testinsertUser() throws Exception {
  46.         String statement = "com.baowei.entity.User.insertUser";// 映射sql的标识字符串
  47.         // 执行查询返回一个唯一user对象的sql
  49.         User user = new User();
  50.         user.setAge(4444);
  51.         user.setName("44");
  53.         sqlSession.insert(statement, user);
  54.         sqlSession.commit();
  55.         System.out.println(user.getId());
  56.     }
  58.     @Test
  59.     public void testdeleteUser() throws Exception {
  60.         String statement = "com.baowei.entity.User.deleteUser";// 映射sql的标识字符串
  61.         // 执行查询返回一个唯一user对象的sql
  63.         sqlSession.insert(statement, 19);
  64.         sqlSession.commit();
  65.     }
  67.     @Test
  68.     public void testupdateUser() throws Exception {
  69.         String statement = "com.baowei.entity.User.updateUser";// 映射sql的标识字符串
  70.         // 执行查询返回一个唯一user对象的sql
  71.         User user = new User();
  72.         user.setId(19);
  73.         user.setAge(122);
  74.         user.setName("12");
  76.         sqlSession.update(statement, user);
  77.         sqlSession.commit();
  78.     }
  80. }

二、使用MyBatis对表执行CRUD操作——基于注解的实现

　　1、定义sql映射的接口

　　IUserMapper接口的代码如下：

  1. import java.util.List;
  2. import org.apache.ibatis.annotations.Delete;
  3. import org.apache.ibatis.annotations.Insert;
  4. import org.apache.ibatis.annotations.Select;
  5. import org.apache.ibatis.annotations.Update;
  7. import com.baowei.entity.User;
  9. public interface IUserMapper {
  10.     // 使用@Insert注解指明add方法要执行的SQL
  11.     @Insert("insert into user(name, age) values(#{name}, #{age})")
  12.     public int add(User user);
  14.     // 使用@Delete注解指明deleteById方法要执行的SQL
  15.     @Delete("delete from user where id=#{id}")
  16.     public int deleteById(int id);
  18.     // 使用@Update注解指明update方法要执行的SQL
  19.     @Update("update user set name=#{name},age=#{age} where id=#{id}")
  20.     public int update(User user);
  22.     // 使用@Select注解指明getById方法要执行的SQL
  23.     @Select("select * from user where id=#{id}")
  24.     public User getById(int id);
  26.     // 使用@Select注解指明getAll方法要执行的SQL
  27.     @Select("select * from user")
  28.     public List<User> getAll();
  29. }

　　需要说明的是，我们不需要针对UserMapperI接口去编写具体的实现类代码，这个具体的实现类由MyBatis帮我们动态构建出来，我们只需要直接拿来使用即可。

　　2、在SqlMapConfig.xml.xml文件中注册这个映射接口

  1. <!DOCTYPE configuration
  2. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  3. "http://mybatis.org/dtd/mybatis-3-config.dtd">
  4. <configuration>
  5.     <properties resource="db.properties">
  6.     </properties>
  7.     <environments default="development">
  8.         <environment id="development">
  9.             <!-- 使用jdbc事务管理，事务控制由mybatis -->
  10.             <transactionManager type="JDBC" />
  11.             <!-- 数据库连接池，由mybatis管理 -->
  12.             <dataSource type="POOLED">
  13.                 <property name="driver" value="${jdbc.driver}" />
  14.                 <property name="url" value="${jdbc.url}" />
  15.                 <property name="username" value="${jdbc.username}" />
  16.                 <property name="password" value="${jdbc.password}" />
  17.             </dataSource>
  18.         </environment>
  19.     </environments>
  20.     <!-- 加载 映射文件 -->
  21.     <mappers>
  22.         <!-- 注册userMapper.xml文件， 19 userMapper.xml位于com.baowei.mapping/这个包下，所以resource写成com/baowei/mapping/userMapper.xml -->
  23.         <!-- <mapper resource="com/baowei/mapping/userMapper.xml" /> -->
  24.         <!-- 注册UserMapper映射接口 -->
  25.         <mapper class="com.baowei.mapping.IUserMapper" />
  26.     </mappers>
  28. </configuration>

　　单元测试类的代码如下：

  1. import java.io.InputStream;
  2. import org.apache.ibatis.io.Resources;
  3. import org.apache.ibatis.session.SqlSession;
  4. import org.apache.ibatis.session.SqlSessionFactory;
  5. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  6. import org.junit.Before;
  7. import org.junit.Test;
  9. import com.baowei.entity.User;
  10. import com.baowei.mapping.IUserMapper;
  12. public class UserDaoAnnationTest {
  14.     private SqlSession sqlSession;
  16.     @Before
  17.     public void setUp() throws Exception {
  19.         String resource = "SqlMapConfig.xml";
  20.         InputStream inputStream = Resources.getResourceAsStream(resource);
  22.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
  23.                 .build(inputStream);
  24.         sqlSession = sqlSessionFactory.openSession();
  25.     }
  27.     @Test
  28.     public void testFindUserById() throws Exception {
  29.         // 得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来
  30.         IUserMapper mapper = sqlSession.getMapper(IUserMapper.class);
  31.         User user = mapper.getById(1);
  32.         // 使用SqlSession执行完SQL之后需要关闭SqlSession
  33.         sqlSession.close();
  34.         System.out.println(user.toString());
  35.     }
  37.     @Test
  38.     public void testinsertUser() throws Exception {
  39.         // 得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来
  40.         IUserMapper mapper = sqlSession.getMapper(IUserMapper.class);
  41.         User user = new User();
  42.         user.setName("666");
  43.         user.setAge(20);
  44.         int add = mapper.add(user);
  45.         sqlSession.commit();
  46.         // 使用SqlSession执行完SQL之后需要关闭SqlSession
  47.         sqlSession.close();
  48.         System.out.println(add);
  49.     }
  51.     @Test
  52.     public void testdeleteUser() throws Exception {
  53.         // 得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来
  54.         IUserMapper mapper = sqlSession.getMapper(IUserMapper.class);
  56.         mapper.deleteById(22);
  57.         sqlSession.commit();
  58.         // 使用SqlSession执行完SQL之后需要关闭SqlSession
  59.         sqlSession.close();
  60.     }
  62.     @Test
  63.     public void testupdateUser() throws Exception {
  64.         // 得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来
  65.         IUserMapper mapper = sqlSession.getMapper(IUserMapper.class);
  66.         User user = new User();
  67.         user.setId(22);
  68.         user.setName("777");
  69.         user.setAge(20);
  70.         mapper.update(user);
  71.         sqlSession.commit();
  72.         // 使用SqlSession执行完SQL之后需要关闭SqlSession
  73.         sqlSession.close();
  75.     }
  77. }

三、使用MyBatis对表执行CRUD操作——基于Mapper代理的实现

  1. 1、定义UserMapper.java的接口，和userMapper.xml的映射文件
  3.     ![20161217133705709][]  
  6. 2、关于userMapper.xml的配置
  8.       ![20161217133813121][]
  10. 3、UserMapper.java的内容
  12. import java.util.List;
  14. import com.baowei.entity.User;
  16. public interface UserMapper {
  18.     public User findUserById(int id) throws Exception;
  20.     public List<User> findUserByName(String name) throws Exception;
  22.     public void insertUser(User user) throws Exception;
  24.     public void deleteUser(int id) throws Exception;
  26.     public void updateUser(User user) throws Exception;
  27. }
  29. 4、userMapper.xml的内容
  31. <?xml version="1.0" encoding="UTF-8" ?>
  32. <!DOCTYPE mapper
  33. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  34. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  36. <!-- namespace命名空间，作用就是对sql进行分类化管理，理解sql隔离 注意：使用mapper代理方法开发，namespace有特殊重要的作用 -->
  37. <mapper namespace="com.baowei.mapper.UserMapper">
  39.     <!-- 在 映射文件中配置很多sql语句 -->
  40.     <!-- 需求：通过id查询用户表的记录 -->
  41.     <!-- 通过 select执行数据库查询 id：标识 映射文件中的 sql 将sql语句封装到mappedStatement对象中，所以将id称为statement的id 
  42.         parameterType：指定输入 参数的类型，这里指定int型 #{}表示一个占位符号 #{id}：其中的id表示接收输入 的参数，参数名称就是id，如果输入 
  43.         参数是简单类型，#{}中的参数名可以任意，可以value或其它名称 resultType：指定sql输出结果 的所映射的java对象类型，select指定resultType表示将单条记录映射成的java对象。 -->
  44.     <select id="findUserById" parameterType="int" resultType="com.baowei.entity.User">
  45.         SELECT
  46.         * FROM USER WHERE id=#{value}
  47.     </select>
  49.     <!-- 根据用户名称模糊查询用户信息，可能返回多条 resultType：指定就是单条记录所映射的java对象 类型 ${}:表示拼接sql串，将接收到参数的内容不加任何修饰拼接在sql中。 
  50.         使用${}拼接sql，引起 sql注入 ${value}：接收输入 参数的内容，如果传入类型是简单类型，${}中只能使用value -->
  51.     <select id="findUserByName" parameterType="java.lang.String"
  52.         resultType="com.baowei.entity.User">
  53.         SELECT * FROM USER WHERE name LIKE '%${value}%'
  54.     </select>
  56.     <!-- 添加用户 parameterType：指定输入 参数类型是pojo（包括 用户信息） #{}中指定pojo的属性名，接收到pojo对象的属性值，mybatis通过OGNL获取对象的属性值 -->
  57.     <insert id="insertUser" parameterType="com.baowei.entity.User">
  58.         <!-- 将插入数据的主键返回，返回到user对象中 SELECT LAST_INSERT_ID()：得到刚insert进去记录的主键值，只适用与自增主键 
  59.             keyProperty：将查询到主键值设置到parameterType指定的对象的哪个属性 order：SELECT LAST_INSERT_ID()执行顺序，相对于insert语句来说它的执行顺序 
  60.             resultType：指定SELECT LAST_INSERT_ID()的结果类型 -->
  61.         <selectKey keyProperty="id" order="AFTER" resultType="int">
  62.             SELECT
  63.             LAST_INSERT_ID()
  64.         </selectKey>
  65.         insert into user(name,age)
  66.         values(#{name},#{age})
  68.     </insert>
  70.     <!-- 删除 用户 根据id删除用户，需要输入 id值 -->
  71.     <delete id="deleteUser" parameterType="java.lang.Integer">
  72.         delete from user where
  73.         id=#{id}
  74.     </delete>
  76.     <!-- 根据id更新用户 分析： 需要传入用户的id 需要传入用户的更新信息 parameterType指定user对象，包括 id和更新信息，注意：id必须存在 
  77.         #{id}：从输入 user对象中获取id属性值 -->
  78.     <update id="updateUser" parameterType="com.baowei.entity.User">
  79.         update user set
  80.         name=#{name},age=#{age}
  81.         where id=#{id}
  82.     </update>
  84. </mapper>
  86.  5、在SqlMapConfig.xml的而配置
  88. <?xml version="1.0" encoding="UTF-8" ?>
  89. <!DOCTYPE configuration
  90. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  91. "http://mybatis.org/dtd/mybatis-3-config.dtd">
  92. <configuration>
  93.     <properties resource="db.properties">
  94.     </properties>
  95.     <environments default="development">
  96.         <environment id="development">
  97.             <!-- 使用jdbc事务管理，事务控制由mybatis -->
  98.             <transactionManager type="JDBC" />
  99.             <!-- 数据库连接池，由mybatis管理 -->
  100.             <dataSource type="POOLED">
  101.                 <property name="driver" value="${jdbc.driver}" />
  102.                 <property name="url" value="${jdbc.url}" />
  103.                 <property name="username" value="${jdbc.username}" />
  104.                 <property name="password" value="${jdbc.password}" />
  105.             </dataSource>
  106.         </environment>
  107.     </environments>
  108.     <!-- 加载 映射文件 -->
  109.     <mappers>
  110.         <mapper class="com.baowei.mapper.UserMapper" />
  111.     </mappers>
  113. </configuration>
  115.  6、测试代码
  117. import java.io.InputStream;
  118. import org.apache.ibatis.io.Resources;
  119. import org.apache.ibatis.session.SqlSession;
  120. import org.apache.ibatis.session.SqlSessionFactory;
  121. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  122. import org.junit.Before;
  123. import org.junit.Test;
  124. import com.baowei.entity.User;
  125. import com.baowei.mapper.UserMapper;
  127. public class UserDaoMapperTest {
  129.     private SqlSession sqlSession;
  131.     @Before
  132.     public void setUp() throws Exception {
  134.         String resource = "SqlMapConfig.xml";
  135.         InputStream inputStream = Resources.getResourceAsStream(resource);
  137.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
  138.                 .build(inputStream);
  139.         sqlSession = sqlSessionFactory.openSession();
  140.     }
  142.     @Test
  143.     public void testFindUserById() throws Exception {
  144.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  145.         User user = mapper.findUserById(1);
  146.         sqlSession.close();
  147.         System.out.println(user.toString());
  148.     }
  150.     @Test
  151.     public void testinsertUser() throws Exception {
  152.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  153.         User user = new User();
  154.         user.setName("666");
  155.         user.setAge(20);
  156.         mapper.insertUser(user);
  157.         sqlSession.commit();
  158.         sqlSession.close();
  159.     }
  161.     @Test
  162.     public void testdeleteUser() throws Exception {
  163.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  164.         mapper.deleteUser(23);
  165.         sqlSession.commit();
  166.         // 使用SqlSession执行完SQL之后需要关闭SqlSession
  167.         sqlSession.close();
  168.     }
  170.     @Test
  171.     public void testupdateUser() throws Exception {
  172.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  173.         User user = new User();
  174.         user.setId(23);
  175.         user.setName("777");
  176.         user.setAge(20);
  177.         mapper.updateUser(user);
  178.         sqlSession.commit();
  179.         // 使用SqlSession执行完SQL之后需要关闭SqlSession
  180.         sqlSession.close();
  182.     }
  184. }

四、代码下载

代码下载

发表评论

表情：
评论列表 （有 0 条评论，285人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Mybatis实现CRUD操作

    项目实现的功能 查询所有用户信息 通过Id查询用户信息 添加用户（回显主键） 修改用户信息 删除用户信息 通过用户名字模糊查询 一、引入依赖和工程

    迷南。迷南。/ 0 赞/ 408 阅读