mybatis(springboot 集成mybatis)

客官°小女子只卖身不卖艺 2022-04-12 13:20 510阅读 0赞
在这漫长的岁月里，一个人敲敲代码也是一件不容易的事情啊

入门

maven构建classpath:

  1. <dependency>
  2.   <groupId>org.mybatis</groupId>
  3.   <artifactId>mybatis</artifactId>
  4.   <version>x.x.x</version>
  5. </dependency>

mybatis-config.xml：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
  3. <configuration>
  4.   <environments default="development">
  5.     <environment id="development">
  6.       <transactionManager type="JDBC"/>
  7.       <dataSource type="POOLED">
  8.         <property name="driver" value="${driver}"/>
  9.         <property name="url" value="${url}"/>
  10.         <property name="username" value="${username}"/>
  11.         <property name="password" value="${password}"/>
  12.       </dataSource>
  13.     </environment>
  14.   </environments>
  15.   <mappers>
  16.     <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  17.   </mappers>
  18. </configuration>

构建SqlSessionFactory:

方法一：

  1. String resource = "org/mybatis/example/mybatis-config.xml";
  2. InputStream inputStream = Resources.getResourceAsStream(resource);
  3. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

方法二：

  1. DataSource dataSource = BlogDataSourceFactory.getBlogDataSource();
  2. TransactionFactory transactionFactory = new JdbcTransactionFactory();
  3. Environment environment = new Environment("development", transactionFactory, dataSource);
  4. Configuration configuration = new Configuration(environment);
  5. configuration.addMapper(BlogMapper.class);
  6. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);

从SqlSessionFactory中构建SqlSession:

方法一：

  1. SqlSession session = sqlSessionFactory.openSession();
  2. try { 
  3.   Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);
  4. } finally { 
  5.   session.close();
  6. }

方法二：

  1. SqlSession session = sqlSessionFactory.openSession();
  2. try { 
  3.   BlogMapper mapper = session.getMapper(BlogMapper.class);
  4.   Blog blog = mapper.selectBlog(101);
  5. } finally { 
  6.   session.close();
  7. }

xml Sql语句编写

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="org.mybatis.example.BlogMapper">
  4.   <select id="selectBlog" resultType="Blog">
  5.     select * from Blog where id = #{id}
  6.   </select>
  7. </mapper>

然后使用Sqlsession进行调用：
方法一：

  1. Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);

这个命名可以直接映射到在命名空间中同名的 Mapper 类，并将已映射的 select 语句中的名字、参数和返回类型匹配成方法。
方法二：

  1. BlogMapper mapper = session.getMapper(BlogMapper.class);
  2. Blog blog = mapper.selectBlog(101);

可以将xml sql语句改为：

  1. public interface BlogMapper { 
  2.   @Select("SELECT * FROM blog WHERE id = #{id}")
  3.   Blog selectBlog(int id);
  4. }

技术实战

  1. //使用@Configuration实现配置
  2. @Configuration
  3. @MapperScan(basePackages = { "xxxx.mapper"}, sqlSessionFactoryRef = "sqlSessionFactory1")
  4. public class MybatisCsmerConfig { 
  5.     @Autowired
  6.     @Qualifier("dataSourceCsmer")
  7.     private DataSource dataSource;
  9.     @Bean
  10.     public SqlSessionFactory sqlSessionFactory1() throws Exception { 
  11.         SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
  12.         factoryBean.setDataSource(dataSource);
  13.         factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver()
  14.                 .getResources("classpath*:mybatis/mapper/*.xml"));
  15.         factoryBean.setConfigLocation(new PathMatchingResourcePatternResolver()
  16.                 .getResource("classpath:mybatis/mybatis-config.xml"));
  17.         return factoryBean.getObject();
  18.     }
  20.     @Bean
  21.     public SqlSessionTemplate sqlSessionTemplate1() throws Exception { 
  22.         SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory1()); // 使用上面配置的Factory
  23.         return template;
  24.     }
  25. }

spring boot集成mybatis

pom.xml中引入依赖：

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>1.3.2.RELEASE</version>
  5.     <relativePath/> <!-- lookup parent from repository -->
  6. </parent>
  8. <dependencies>
  10.     <dependency>
  11.         <groupId>org.springframework.boot</groupId>
  12.         <artifactId>spring-boot-starter</artifactId>
  13.     </dependency>
  15.     <dependency>
  16.         <groupId>org.springframework.boot</groupId>
  17.         <artifactId>spring-boot-starter-test</artifactId>
  18.         <scope>test</scope>
  19.     </dependency>
  21.     <dependency>
  22.         <groupId>org.mybatis.spring.boot</groupId>
  23.         <artifactId>mybatis-spring-boot-starter</artifactId>
  24.         <version>1.1.1</version>
  25.     </dependency>
  27.     <dependency>
  28.         <groupId>mysql</groupId>
  29.         <artifactId>mysql-connector-java</artifactId>
  30.         <version>5.1.21</version>
  31.     </dependency>
  32. </dependencies>

在application.properties中配置mysql的连接配置

  1. spring.datasource.url=jdbc:mysql://localhost:3306/test
  2. spring.datasource.username=root
  3. spring.datasource.password=123456
  4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver

然后写一个例子：

  1. //使用@Mapper注解，告诉spring boot自动扫描这个类为mapper
  2. import org.apache.ibatis.annotations.*;
  4. @Mapper
  5. public interface UserMapper { 
  7.     @Select("SELECT * FROM USER WHERE NAME = #{name}")
  8.     User findByName(@Param("name") String name);
  10.     @Insert("INSERT INTO USER(NAME, AGE) VALUES(#{name}, #{age})")
  11.     int insert(@Param("name") String name, @Param("age") Integer age);
  13. }

相应的实体：

  1. public class User { 
  3.     private Long id;
  4.     private String name;
  5.     private Integer age;
  7.     public Long getId() { 
  8.         return id;
  9.     }
  11.     public void setId(Long id) { 
  12.         this.id = id;
  13.     }
  15.     public String getName() { 
  16.         return name;
  17.     }
  19.     public void setName(String name) { 
  20.         this.name = name;
  21.     }
  23.     public Integer getAge() { 
  24.         return age;
  25.     }
  27.     public void setAge(Integer age) { 
  28.         this.age = age;
  29.     }
  31. }

springboot整合mybatis会自动配置完所有信息，用户只需要在写的时候加入@Mapper注解，会自动进行扫描。

原理：

mybatis-spring-boot-starter就是springboot+mybatis可以完全注解不用配置文件，mybatis-spring-boot-starter主要有两种解决方案，一种是使用注解解决一切问题，一种是简化后的老传统。springboot会自动加载spring.datasource.*相关配置，数据源就会自动注入到sqlSessionFactory中，sqlSessionFactory会自动注入到Mapper中，对了你一切都不用管了，直接拿起来使用就行了。
首先，在启动类中添加对mapper包扫描@MapperScan

  1. @SpringBootApplication
  2. @MapperScan("com.neo.mapper")
  3. public class Application { 
  5.     public static void main(String[] args) { 
  6.         SpringApplication.run(Application.class, args);
  7.     }
  8. }

方式一：
直接在Mapper类上面添加注解@Mapper。
####Mapper的写法

  1. public interface UserMapper { 
  3.     @Select("SELECT * FROM users")
  4.     @Results({ 
  5.         @Result(property = "userSex",  column = "user_sex", javaType = UserSexEnum.class),
  6.         @Result(property = "nickName", column = "nick_name")
  7.     })
  8.     List<UserEntity> getAll();
  10.     @Select("SELECT * FROM users WHERE id = #{id}")
  11.     @Results({ 
  12.         @Result(property = "userSex",  column = "user_sex", javaType = UserSexEnum.class),
  13.         @Result(property = "nickName", column = "nick_name")
  14.     })
  15.     UserEntity getOne(Long id);
  17.     @Insert("INSERT INTO users(userName,passWord,user_sex) VALUES(#{userName}, #{passWord}, #{userSex})")
  18.     void insert(UserEntity user);
  20.     @Update("UPDATE users SET userName=#{userName},nick_name=#{nickName} WHERE id =#{id}")
  21.     void update(UserEntity user);
  23.     @Delete("DELETE FROM users WHERE id =#{id}")
  24.     void delete(Long id);
  26. }

注解解释

  1. @Select 是查询类的注解，所有的查询均使用这个
  2. @Result 修饰返回的结果集，关联实体类属性和数据库字段一一对应，如果实体类属性和数据库属性名保持一致，就不需要这个属性来修饰。
  3. @Insert 插入数据库使用，直接传入实体类会自动解析属性到对应的值
  4. @Update 负责修改，也可以直接传入对象
  5. @delete 负责删除

注意，使用#符号和$符号的不同：

  1. // This example creates a prepared statement, something like select * from teacher where name = ?;
  2. @Select("Select * from teacher where name = #{name}")
  3. Teacher selectTeachForGivenName(@Param("name") String name);
  5. // This example creates n inlined statement, something like select * from teacher where name = 'someName';
  6. @Select("Select * from teacher where name = '${name}'")
  7. Teacher selectTeachForGivenName(@Param("name") String name);

方式二：极简xml
application.properties新增以下配置

  1. mybatis.config-locations=classpath:mybatis/mybatis-config.xml
  2. mybatis.mapper-locations=classpath:mybatis/mapper/*.xml

mybatis-config.xml 配置:

  1. <configuration>
  2.     <typeAliases>
  3.         <typeAlias alias="Integer" type="java.lang.Integer" />
  4.         <typeAlias alias="Long" type="java.lang.Long" />
  5.         <typeAlias alias="HashMap" type="java.util.HashMap" />
  6.         <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
  7.         <typeAlias alias="ArrayList" type="java.util.ArrayList" />
  8.         <typeAlias alias="LinkedList" type="java.util.LinkedList" />
  9.     </typeAliases>
  10. </configuration>

添加映射文件：

  1. <mapper namespace="com.neo.mapper.UserMapper" >
  2.     <resultMap id="BaseResultMap" type="com.neo.entity.UserEntity" >
  3.         <id column="id" property="id" jdbcType="BIGINT" />
  4.         <result column="user_name" property="userName" jdbcType="VARCHAR" />
  5.         <result column="pass_word" property="passWord" jdbcType="VARCHAR" />
  6.         <result column="user_sex" property="userSex" javaType="com.neo.enums.UserSexEnum"/>
  7.         <result column="nick_name" property="nickName" jdbcType="VARCHAR" />
  8.     </resultMap>
  10.     <sql id="Base_Column_List" >
  11.         id, userName, passWord, user_sex, nick_name
  12.     </sql>
  14.     <select id="getAll" resultMap="BaseResultMap" >
  15.        SELECT 
  16.        <include refid="Base_Column_List" />
  17.        FROM users
  18.     </select>
  20.     <select id="getOne" parameterType="java.lang.Long" resultMap="BaseResultMap" >
  21.         SELECT 
  22.        <include refid="Base_Column_List" />
  23.        FROM users
  24.        WHERE id = #{id}
  25.     </select>
  27.     <insert id="insert" parameterType="com.neo.entity.UserEntity" >
  28.        INSERT INTO 
  29.                users
  30.                (userName,passWord,user_sex) 
  31.            VALUES
  32.                (#{userName}, #{passWord}, #{userSex})
  33.     </insert>
  35.     <update id="update" parameterType="com.neo.entity.UserEntity" >
  36.        UPDATE 
  37.                users 
  38.        SET 
  39.            <if test="userName != null">userName = #{userName},</if>
  40.            <if test="passWord != null">passWord = #{passWord},</if>
  41.            nick_name = #{nickName}
  42.        WHERE 
  43.                id = #{id}
  44.     </update>
  46.     <delete id="delete" parameterType="java.lang.Long" >
  47.        DELETE FROM
  48.                 users 
  49.        WHERE 
  50.                 id =#{id}
  51.     </delete>
  52. </mapper>

其实就是把上个版本中mapper的sql搬到了这里的xml中了。

我们的结构原本是按照第二种模式动态生成sqlnode，为了增强代码的可维护性，我们使用了mybatis的拦截器方法将动态生成改为更加简单的通过java语言来控制，而不需要去修改xml语句。见下文

发表评论

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

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

相关阅读