Fundação Spring (6) Integração de Mybatis

O pacote do frasco de mybatis-spring precisa ser carregado.

Porque também existem muitos novos objetos em mybatis, como SqlSession, etc., que podem ser colocados na primavera para hospedagem.

<!-- spring操作数据库还需要一个spring-jdbc的包 -->
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <!-- 与webmvc版本相同 -->
        <version>5.2.0.RELEASE</version>
    </dependency>
    
    <dependency>
    	<groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.2</version>
    </dependency>
    
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.3</version>
    </dependency>
</dependencies>

Nota! O pacote jar de mybatis é necessário durante a configuração, Caso contrário, relatar: Bean deve ser of'org.apache.ibatis.session.SqlSessionFactory '

Mybatis-Spring

mybatis-spring irá ajudá-lo a integrar o código mybatis no Spring!

Etapas para uso:

Importe o pacote do frasco de mybatis-spring
É necessário construir uma SqlSessionFactory no contêiner spring (Esta fábrica precisa da criação da fonte de dados）
Precisa construir um DataSource no container spring (Por estar originalmente no arquivo de configuração conf, use a fonte de dados do spring para substituir a fonte de dados no arquivo de configuração.） Org.springframework.jdbc.datasource.DriverManagerDataSource
Gere sqlSession por meio de SqlSessionTemplate (O modelo precisa ser injetado em sqlSessionFactory）
Adicione uma classe de implementação à interface do mapeador (Como a interface não pode ser um novo objeto, o objeto mapeador não pode ser adicionado ao container spring, então a classe de implementação é necessária）

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 创建一个spring的数据源对象 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="111111"/>
    </bean>

    <!-- 根据数据源创建一个sqlSessionFactory对象 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 以下属性不是必须的，绑定mybatis的配置文件，这样这个sqlSessionFactory就可以根据mybatis的配置文件的一些信息生成 -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>
    
    <!-- 使用模板生成sqlSession，模板是根据SQLSessionFactory生成sqlSession -->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

</beans>

No sqlSessionFactory original foi gerado com base no arquivo de configuração conf de mybatis, agora é gerado após a configuração no bean, == portanto, este bean SQLSessionFactory pode configurar tudo no arquivo mybatis-conf (incluindo a conexão com o arquivo de configuração mybaits-conf ) == Mas a fonte de dados é obrigatória!

Assim, o arquivo de configuração mybatis pode ser completamente substituído.

Geralmente, existem dois itens deixados no arquivo mybatis-conf:Gerenciamento de alias; gerenciamento de configurações. Em seguida, use configLocation para se conectar.

public class User {
    
    
    private String name;
    public User() {
    
    
    }
    public User(String name) {
    
    
        this.name = name;
    }
    public String getName() {
    
    
        return name;
    }
    public void setName(String name) {
    
    
        this.name = name;
    }
}

public interface UserMapper {
    
    
    List<User> getUsers();
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org/DTD Mapper 3.0"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.qiu.mapper.UserMapper">
    <select id="getUsers" resultType="User">
        select * from `user`
    </select>
</mapper>

Acontece que o objeto mapeador é usado na camada de serviço. Depois de usar spring, você precisa colocar o objeto mapper no container spring, mas não há nenhuma classe correspondente para gerá-lo, então você só pode implementar o seguinte UserMapper como uma classe de implementação para gerar o objeto mapper e colocá-lo no container spring para gerenciamento!

De acordo com os mybaits originais, o mapeador é gerado por meio de reflexão. Mas a interface não pode criar objetos, portanto, não pode ser colocada no recipiente da mola. Não há outra maneira senão adicionar outra camada de Impl para implementar a interface de forma que ele possa criar objetos.

public class UserMapperImpl implements UserMapper {
    
    
    SqlSessionTemplate sqlSession;

    @Override
    public List<User> getUsers() {
    
    
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.getUsers();
        return users;
    }

    public SqlSessionTemplate getSqlSession() {
    
    
        return sqlSession;
    }
    public void setSqlSession(SqlSessionTemplate sqlSession) {
    
    
        this.sqlSession = sqlSession;
    }
}

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <import resource="spring-dao.xml"/>

    <bean id="userMapper" class="com.qiu.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

</beans>

SqlSessionDaoSupport

Esta é uma classe abstrata fornecida por mybatis-spring. Com esta classe, não há necessidade de escrever sqlSession (ou seja , não há necessidade de configurar sqlSession no container spring, mas Factory e DataSource também são necessários)

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper{
    
    
    public getUsers(){
    
    
        SqlSession session = getSqlSession();
        retuen session.selectLise("com.qiu.mapper.UserMapper.getUsers");
    }
}

<bean id="userMapper" class="com.qiu.mapper.UserMapperImpl">
	<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

Na verdade, isso não simplifica muito, apenas não precisa registrar sqlSession na primavera. A operação anterior precisa registrar o SqlSessionTemplate no container spring e injetá-lo no UserMapperImpl para uso na criação de sqlSession.

Apenas uma operação de injeção a menos. E a injeção do bean userMapper é uma fábrica de injeção (exigida pela classe pai SqlSessionDaoSupport)

Transação declarativa

A principal razão para usar o mybatis-spring é que ele permite que o mybatis participe do gerenciamento de transações do spring. Em vez de criar um novo gerenciador de transações dedicado para mybatis, mybatis-spring usa a classe DataSourceTransactionManager de spring para implementar o gerenciamento de transações,

Para ativar a função de processamento de transações do spring, crie um objeto DataSourceTransactionManager nos beans do arquivo de configuração do spring:

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSoueceTransactionManager">
	<constructor-arg ref="dataSource"/>
</bean>

Existem dois métodos de gerenciamento de transações na primavera:

Transação declarativa: implementação de AOP
Transações programáticas: necessidade de alterar o código original

Etapas de implementação:

Crie um objeto de gerenciamento de transação e entregue-o ao container spring para gerenciar (indicando que a fonte é gerenciada pela transação. Porque uma fonte possui qual banco de dados e qual banco de dados é usado)Crie uma classe de aspecto. Este aspecto é fornecido pela mybatis-spring para você! Você só precisa criar objetos e configurar classes de aspecto!
```
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSoueceTransactionManager">
	<constructor-arg ref="dataSource"/>
</bean>
```

Configure a notificação da transação (notificação é o método a ser inserido. Isso indica que todos os métodos de adição e exclusão devem ser inseridos)Configure esta classe de aspecto

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/aop/spring-tx.xsd">
<!-- 注意这里的头信息需要配置 -->
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSoueceTransactionManager">
        <constructor-arg ref="dataSource"/>
    </bean>
    
    <!-- 配置事务的通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 给哪些方法配置事务 -->
    	<tx:attributes>
            <!-- 给所有的add、delete方法添加事务 -->
        	<tx:method name="add"/>
            <tx:method name="delete"/>
            <!-- 给所有的方法添加事务（增删改查） -->
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

</beans>

Você pode pensar em transactionManager como uma classe de aspecto e o conselho é uma notificação para configurar a classe de aspecto!

Entrada de transação de configuração.Corte o macarrão no ponto de entrada

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSoueceTransactionManager">
    <constructor-arg ref="dataSource"/>
</bean>

<!-- 配置事务的通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!-- 给哪些方法配置事务 -->
    <tx:attributes>
        <!-- 给所有的add、delete方法添加事务 -->
        <tx:method name="add"/>
        <tx:method name="delete"/>
        <!-- 给所有的方法添加事务（增删改查） -->
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

<aop:config>
	<aop:pointcut id="txPointCut" expression="execution(* com.qiu.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>

Observe que o ponto de entrada aqui são todos os métodos de todas as classes do mapeador no pacote do mapeador.Como o método na classe mapeador é o método mais atômico, depois que esses métodos de operação jdbc atômicos oferecem suporte a transações, o método mapeador usado no serviço naturalmente oferece suporte a transações

Princípios básicos da primavera (6)

Artigo Diretório

Fundação Spring (6) Integração de Mybatis

Mybatis-Spring

SqlSessionDaoSupport

Transação declarativa

Acho que você gosta