Nutzen Sie mybatis elegant

Die Verwendung von Mybatis ist in der Anfangsphase recht mühsam. Es erfordert verschiedene Konfigurationsdateien, Entitätsklassen, Dao-Layer-Mapping-Zuordnungen und viele andere Konfigurationen. Natürlich hat mybatis auch dieses Manko entdeckt und einen Generator entwickelt, der automatisch Entitätsklassen, Konfigurationsdateien und DAO-Layer-Codes basierend auf Tabellenergebnissen erstellen kann, was einen Teil des Entwicklungsaufwands reduzieren kann Es wurden auch zahlreiche Optimierungen vorgenommen, um Annotationen zu verwenden und DAOs, Konfigurationsdateien usw. automatisch zu verwalten. Dies ist das Modell, über das ich heute sprechen werde .Mybatis kann ohne Konfigurationsdatei vollständig mit Anmerkungen versehen und außerdem einfach konfiguriert und verwendet werden.

Wenn ich jetzt darüber nachdenke, ist Spring Boot einfach großartig. Alles, was mit Spring Boot zu tun hat, ist vereinfacht.

mybatis-spring-boot-starter

Offizielle Beschreibung: MyBatis Spring-Boot-Starter hilft Ihnen bei der Verwendung von MyBatis mit Spring Boot
Tatsächlich wurde es von myBatis entwickelt, nachdem Sie gesehen hatten, wie Der beliebte Spring Boot ist eine Reihe von Lösungen, mit denen man Spaß haben kann, aber dieser löst viele Probleme und ist in der Tat viel einfacher zu verwenden. Mybatis-Spring-Boot-Starter bietet hauptsächlich zwei Lösungen: Eine besteht darin, Anmerkungen zu verwenden, um alle Probleme zu lösen, und die andere ist die vereinfachte alte Tradition.

Natürlich muss in jedem Modus zuerst die POM-Datei von mybatis-spring-boot-starter eingeführt werden. Die neueste Version ist jetzt 1.1.1

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version></dependency>

Okay, stellen wir uns die beiden vor Entwicklungsmodi separat

Keine Konfigurationsdatei-Anmerkungsversion

Alles wird mithilfe von Anmerkungen erledigt.

1 Zugehörige Maven-Dateien hinzufügen

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.1.1</version>
    </dependency>
     <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
     <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency></dependencies>

Das vollständige POM-Paket wird hier nicht veröffentlicht, Sie können sich den Quellcode direkt ansehen

2 Application.properties Hinzufügen Verwandte Konfiguration

mybatis.type-aliases-package=com.neo.entity

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8spring.datasource.username = root
spring.datasource.password = root

springboot lädt automatisch spring.datasource.*-bezogene Konfiguration, die Datenquelle wird automatisch in sqlSessionFactory injiziert, sqlSessionFactory wird automatisch in Mapper injiziert, das haben Sie übrigens nicht Um sich um irgendetwas zu kümmern, heben Sie es einfach auf und verwenden Sie es. Das ist alles.

Fügen Sie @MapperScan hinzu, um das Mapper-Paket in der Startup-Klasse zu scannen

@SpringBootApplication@MapperScan("com.neo.mapper")public class Application {    
public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Oder fügen Sie die Annotation @Mapper direkt zur Mapper-Klasse hinzu. Es wird empfohlen, die obige zu verwenden, andernfalls hinzufügen eine Anmerkung zu jedem Mapper Es ist auch ziemlich mühsam

3. Mapper entwickeln

Der dritte Schritt ist der kritischste Teil hier

public interface UserMapper {

    @Select("SELECT * FROM users")
    @Results({
        @Result(property = "userSex",  column = "user_sex", javaType = UserSexEnum.class),
        @Result(property = "nickName", column = "nick_name")
    })
    List<UserEntity> getAll();

    @Select("SELECT * FROM users WHERE id = #{id}")
    @Results({
        @Result(property = "userSex",  column = "user_sex", javaType = UserSexEnum.class),
        @Result(property = "nickName", column = "nick_name")
    })
    UserEntity getOne(Long id);

    @Insert("INSERT INTO users(userName,passWord,user_sex) VALUES(#{userName}, #{passWord}, #{userSex})")
    void insert(UserEntity user);

    @Update("UPDATE users SET userName=#{userName},nick_name=#{nickName} WHERE id =#{id}")
    void update(UserEntity user);

    @Delete("DELETE FROM users WHERE id =#{id}")
    void delete(Long id);

}

Hinweis: Verwenden Sie #-Symbole und $-Unterschiede in den Symbolen:

// This example creates a prepared statement, something like select * from teacher where name = ?;
@Select("Select * from teacher where name = #{name}")
Teacher selectTeachForGivenName(@Param("name") String name);

// This example creates n inlined statement, something like select * from teacher where name = 'someName';
@Select("Select * from teacher where name = '${name}')
Teacher selectTeachForGivenName(@Param("name") String name);

4. Verwenden Sie

, um die Entwicklung der relevanten Dao-Ebene in den oben genannten drei Schritten abzuschließen als normale Klasseninjektion

@RunWith(SpringRunner.class)@SpringBootTestpublic class UserMapperTest {    @Autowired
    private UserMapper UserMapper;    @Test
    public void testInsert() throws Exception {
        UserMapper.insert(new UserEntity("aa", "a123456", UserSexEnum.MAN));
        UserMapper.insert(new UserEntity("bb", "b123456", UserSexEnum.WOMAN));
        UserMapper.insert(new UserEntity("cc", "b123456", UserSexEnum.WOMAN));

        Assert.assertEquals(3, UserMapper.getAll().size());
    }    @Test
    public void testQuery() throws Exception {
        List<UserEntity> users = UserMapper.getAll();
        System.out.println(users.toString());
    }    @Test
    public void testUpdate() throws Exception {
        UserEntity user = UserMapper.getOne(3l);
        System.out.println(user.toString());
        user.setNickName("neo");
        UserMapper.update(user);
        Assert.assertTrue(("neo".equals(UserMapper.getOne(3l).getNickName())));
    }
}

Minimalistische XML-Version

Die minimalistische XML-Version behält die alte Tradition der Zuordnung von Dateien bei. Die Optimierung spiegelt sich hauptsächlich in der Implementierungsschicht wider, die kein Dao implementieren muss . Das System fügt den Methodennamen automatisch entsprechend dem Methodennamen in die Zuordnungsdatei ein.

1、配置

pom文件和上个版本一样，只是application.properties新增以下配置

mybatis.config-locations=classpath:mybatis/mybatis-config.xm

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

指定了mybatis基础配置文件和实体类映射文件的地址

mybatis-config.xml 配置

<configuration>
    <typeAliases>
        <typeAlias alias="Integer" type="java.lang.Integer" />
        <typeAlias alias="Long" type="java.lang.Long" />
        <typeAlias alias="HashMap" type="java.util.HashMap" />
        <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
        <typeAlias alias="ArrayList" type="java.util.ArrayList" />
        <typeAlias alias="LinkedList" type="java.util.LinkedList" />
    </typeAliases></configuration>

这里也可以添加一些mybatis基础的配置

2、添加User的映射文件

<mapper namespace="com.neo.mapper.UserMapper" >
    <resultMap id="BaseResultMap" type="com.neo.entity.UserEntity" >
        <id column="id" property="id" jdbcType="BIGINT" />
        <result column="userName" property="userName" jdbcType="VARCHAR" />
        <result column="passWord" property="passWord" jdbcType="VARCHAR" />
        <result column="user_sex" property="userSex" javaType="com.neo.enums.UserSexEnum"/>
        <result column="nick_name" property="nickName" jdbcType="VARCHAR" />
    </resultMap>

    <sql id="Base_Column_List" >
        id, userName, passWord, user_sex, nick_name    </sql>

    <select id="getAll" resultMap="BaseResultMap"  >
       SELECT 
       <include refid="Base_Column_List" />
       FROM users    </select>

    <select id="getOne" parameterType="java.lang.Long" resultMap="BaseResultMap" >
        SELECT 
       <include refid="Base_Column_List" />
       FROM users
       WHERE id = #{id}
    </select>

    <insert id="insert" parameterType="com.neo.entity.UserEntity" >
       INSERT INTO 
               users
               (userName,passWord,user_sex) 
           VALUES
               (#{userName}, #{passWord}, #{userSex})    </insert>

    <update id="update" parameterType="com.neo.entity.UserEntity" >
       UPDATE 
               users 
       SET 
           <if test="userName != null">userName = #{userName},</if>
           <if test="passWord != null">passWord = #{passWord},</if>
           nick_name = #{nickName}
       WHERE 
               id = #{id}
    </update>

    <delete id="delete" parameterType="java.lang.Long" >
       DELETE FROM
                users 
       WHERE 
                id =#{id}
    </delete></mapper>

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

3、编写Dao层的代码

public interface UserMapper {

    List<UserEntity> getAll();

    UserEntity getOne(Long id);

    void insert(UserEntity user);

    void update(UserEntity user);

    void delete(Long id);

}

对比上一步这里全部只剩了接口方法

如何选择

两种模式各有特点，注解版适合简单快速的模式，其实像现在流行的这种微服务模式，一个微服务就会对应一个自已的数据库，多表连接查询的需求会大大的降低，会越来越适合这种模式。

老传统模式比适合大型项目，可以灵活的动态生成SQL，方便调整SQL，也有痛痛快快，洋洋洒洒的写SQL的感觉。