Java | Spring框架学习笔记--(3)持久层整合

最新推荐文章于 2021-04-28 22:21:16 发布
最新推荐文章于 2021-04-28 22:21:16 发布
阅读量220 收藏 1
点赞数
分类专栏： # Spring全家桶 文章标签： java spring mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45740349/article/details/113323531
版权

系列文章：
Java | Spring框架学习笔记–(1)工厂
Java | Spring框架学习笔记–(2)AOP
Java | Spring框架学习笔记–(3)持久层整合
Java | Spring框架学习笔记–(4)MVC框架整合
Java | Spring框架学习笔记–(5)注解编程

持久层整合

Spring框架为什么要与持久层技术进行整合？

  1. JavaEE开发需持久层进行数据库的访问操作
  2. JDBC Hibernate MyBatis 进行持久层开发过程存在大量的代码冗余
  3. Spring基于模板设计模式对于上述的持久层技术进行了封装

Spring可以与哪些持久性技术整合？

  1. JDBC – JdbcTemplate
  2. Hibernate(JPA) – HibernateTemplate
  3. MyBatis – SqlSessionFactoryBean MapperScannerConfigure

Spring与MyBatis整合

  1. 数据表

    create table users(
	id primary key auto_increment,
    username varchar(16),
    password varchar(16)
)

  2. 实体类

    public class User implements Serializable {
    private int id;
    private String username;
    private String password;
	//---构造方法、getter/setter/toString略--
}

  3. DAO接口

    public interface UserDao {
    void insert(User user);
}

  4. 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>
    <typeAliases>
        <typeAlias type="com.prince.User" alias="user" />
    </typeAliases>

    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--com.mysql.jdbc.Driver过期了 -->
                <property name="url" value="jdbc:mysql:///mydata"/>
                <!-- 实验证明URL后面不加“?serverTimezone=UTC”会报异常 -->
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="Mapper.xml"/>
    </mappers>
</configuration>

  5. Mapper.xml

    <?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.prince.UserDao">
    <!-- namespace放接口的全类名 -->
    <insert id="insert" parameterType="user">
        insert into users(username,password) values(#{username},#{password});
    </insert>
</mapper>

  6. 测试类

    import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;

public class TestMybatis {
    @Test
    public void test() throws IOException {
        InputStream in = TestMybatis.class.getResourceAsStream("/SqlMapConfig.xml");
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sessionFactory.openSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        userDao.insert(new User("mpr","456789"));
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }
}

Mybatis开发中存在的问题

配置繁琐 代码冗余

  1. 实体
  2. 实体别名 配置繁琐
  3. 表
  4. 创建DAO接⼝
  5. 实现Mapper⽂件
  6. 注册Mapper⽂件 配置繁琐
  7. MybatisAPI调⽤ 代码冗余

Spring整合MyBatis分析

  1. 创建SqlSessionFactory过于繁琐，SqlMapConfig.xml的配置也过于复杂

    InputStream in = TestMybatis.class.getResourceAsStream("/SqlMapConfig.xml");
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);

    Spring的整合方法：SqlSessionFactoryBean对象，在applicationContext.xml中配置这个对象的时候

    通过dataSource属性指定数据库连接池
    通过typeAliasesPackage属性指定别名（传实体类所在的包进去，Spring会自动给这个包下的类设置别名，比如这个包下有一个User类，那么就会有一个别名叫做User）
    通过mapperLocations属性指定Mapper.xml所在的位置（可以使用通用配置，比如*Mapper.xml代表的是所有以Mapper.xml结尾的文件）

  2. 创建SqlSession和DAO的时候，Spring也进行了整合

    SqlSession sqlSession = sessionFactory.openSession();
UserDao userDao = sqlSession.getMapper(UserDao.class);

    使用到的类是MapperScannerConfigure，在applicationContext.xml中配置这个对象的时候
    通过sqlSessionFactoryBeanName 属性来指定上一步创建的那个SqlSessionFactoryBean对象，value是这个对象的id值
    通过basePackage属性来指定DAO接口所在的包
    创建DAO接口的时候，直接在Spring中通过getBean()传入id获取，id为DAO接口的名称，首字母小写。比如UserDAO，id就是userDAO

Spring整合Mabatis开发步骤

  • 环境配置（3个jar包）

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.1</version>
</dependency>

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.2</version>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.9</version>
</dependency>

  • applicationContext.xml的配置

    <!--配置数据库连接池-->
<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydata"/>
    <property name="username" value="root" />
    <property name="password" value="root" />
</bean>

<!--配置SqlSessionFactoryBean-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean" id="factoryBean">
    <!--指定DataSource数据库连接池-->
    <property name="dataSource" ref="dataSource" />
    <!--给实体类设置别名-->
    <property name="typeAliasesPackage" value="com.prince.entity" />
    <!--设置mapper.xml的文件路径-->
    <property name="mapperLocations">
        <list>
            <value>mapper/*Mapper.xml</value>
        </list>
    </property>
</bean>

<!--配置MapperScannerConfigurer-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" id="configurer">
    <!--SqlSessionFactoryBean-->
    <property name="sqlSessionFactoryBeanName" value="factoryBean" />
    <!--指定Dao接口所在的包-->
    <property name="basePackage" value="com.prince.dao" />
</bean>

  • 测试类

    public class TestSpringMybatis {
    @Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = applicationContext.getBean("userDao", UserDao.class);	//直接通过getBean()传入id来获取对象，id值就是Dao借口的名字，首字母小写
        userDao.insert(new User("anong","fdsjh"));
    }
}

细节：Spring整合MyBatis的时候，插入数据时，不需要commit()，会自动提交，而原来的Mybatis需要手动提交事务。

分析：本质上控制连接对象（Connection）的是—>连接池（DataSource）

  1. MyBatis提供的连接池对象，创建Connection的时候会自动将Connection设置为手动提交事务

    Connection.setAutoCommit(false);

  2. Spring整合Mybatis的时候，我们使用的是Druid连接池，这些连接池在创建对象的时候不会设置setAutoCommit为false，而是保持默认值true，即会自动提交事务。

未来实战中，还会设置手动提交事务，Spring可以通过事务控制解决这个问题。

Spring的事务处理

事务：保证业务操作完整性的一种数据库机制
事务的4个特点：A（原子性）、C（一致性）、I（隔离性）、D（持久性）

如何控制事务？

JDBC：
	Connection.setAutoCommit(false);  开启事务
	Connection.commit();			提交事务
	Connection.rollback();			回滚
MyBatis：
	自动开启事务
	sqlSession.commit();	提交事务
	sqlSession.rollback();	回滚
（Mybatis控制事务的底层 都是通过Connection来实现的）

Spring控制事务分析

Spring是通过AOP的方式来控制事务开发的

在这里插入图片描述
在这里插入图片描述

Spring控制事务编码

  1. 导入依赖jar包

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.3.1</version>
</dependency>

  2. 配置ApplicationContext.xml

    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">
    <!--传入dataSource数据库连接池-->
    <property name="dataSource" ref="dataSource"/>
</bean>

<!--组装切面-->
<tx:annotation-driven transaction-manager="dataSourceTransactionManager" />

    注意：<tx:annotation-driven>标签在写上<tx:anno后，idea有多个提示，要选择链接是tx结尾的那个！
    在这里插入图片描述

    组装切面的时候，也可以指定proxy-target-class属性为true，来代表使用CGlib的代理模式

    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true" />

  3. UserService

    public interface UserService {

    void insert(User user);
}


    @Transactional  //给这个类的所有方法都加入事务
public class UserServiceImpl implements UserService{
    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void insert(User user) {
        userDao.insert(user);
    }
}

  4. applicationContext.xml里面配置UserService

    <bean class="com.prince.service.UserServiceImpl" id="userService">
    <!--Spring与Mybatis整合的时候会创建一个UserDao，直接把这个UserDao注入即可-->
    <property name="userDao" ref="userDao"/>
</bean>

  5. 测试类

    @Test
public void test2(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userService = applicationContext.getBean("userService", UserService.class);
    userService.insert(new User("interesting","hhhhaaaa"));
}

注意：不需要手动提交事务，当UserService的方法抛出异常时，会自动回滚。

完整的配置代码：

<?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:context="http://www.springframework.org/schema/context"
       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/context
        http://www.springframework.org/schema/context/spring-context.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/tx/spring-tx.xsd">

    <!--配置数据库连接池-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydata"/>
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>

    <!--配置SqlSessionFactoryBean-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="factoryBean">
        <!--指定DataSource数据库连接池-->
        <property name="dataSource" ref="dataSource" />
        <!--给实体类设置别名-->
        <property name="typeAliasesPackage" value="com.prince.entity" />
        <!--设置mapper.xml的文件路径-->
        <property name="mapperLocations">
            <list>
                <value>mapper/*Mapper.xml</value>
            </list>
        </property>
    </bean>

    <!--配置MapperScannerConfigurer-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" id="configurer">
        <!--SqlSessionFactoryBean-->
        <property name="sqlSessionFactoryBeanName" value="factoryBean" />
        <!--指定Dao接口所在的包-->
        <property name="basePackage" value="com.prince.dao" />

    </bean>

    <!--上面是Spring整合Mybatis-->

    <!--额外功能-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">
        <!--传入dataSource数据库连接池-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--组装切面-->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true" />

    <!--创建UserService对象-->
    <bean class="com.prince.service.UserServiceImpl" id="userService">
        <!--Spring与Mybatis整合的时候会创建一个UserDao，直接把这个UserDao注入即可-->
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

Spring的事务属性

属性：描述物体特征的一系列值（性别、身高、体重、…）
事务属性：描述事务特征的一系列值，主要有5个方面：隔离属性、传播属性、只读属性、超时属性、异常属性

隔离属性(isolation)

概念：描述了事务解决并发问题的特征
并发：多个事务在同一时间内，访问操作了相同的数据
产生的问题：脏读、不可重复读、幻影读
解决：通过隔离属性解决，隔离属性设置不同的值，解决并发的问题

  • 脏读：⼀个事务，读取了另⼀个事务中没有提交的数据。会在本事务中产⽣数据不⼀致的问题
    解决：

    @Transactional(isolation=Isolation.READ_COMMITTED)

  • 不可重复读：一个事务中，多次读取相同的数据，但是读取结果不一样，产生数据不一致的问题。
    注意：1. 不是脏读 2. 一个事务中
    解决：

    @Transactional(isolation = Isolation.REPEATABLE_READ)

    本质：一把行锁

  • 幻影读：一个事务中，多次对整表进行查询统计，但是结果不一样，会在本事务中产生数据不一致的问题
    解决：

    @Transactional(isolation = Isolation.SERIALIZABLE)

    本质：表锁

总结：
并发安全：SERIALIZABLE > REPEATABLE_READ > READ_COMMITTED
运行效率：READ_COMMITTED > REPEATABLE_READ > SERIALIZABLE

数据库对隔离属性的支持：

隔离属性的值MysqlOracle
READ_COMMITTED支持支持
REPEATABLE_READ支持不支持
SERIALIZABLE支持支持

Oracle不支持REPEATABLE_READ的值，采用多版本比对的方式解决不可重复读的问题。

默认隔离属性（ISOLATION_DEFAULT）：会调用不同数据库数组的默认隔离属性
MySQL --> REPEATABLE_READ
Oracle --> READ_COMMITTED

查看数据库的默认隔离属性

-- MySQL
select @@tx_isolation;

-- Oracle
SELECT s.sid, s.serial#,
	CASE BITAND(t.flag, POWER(2, 28))
		WHEN 0 THEN 'READ COMMITTED'
		ELSE 'SERIALIZABLE'
	END AS isolation_level
FROM v$transaction t
JOIN v$session s ON t.addr = s.taddr
AND s.sid = sys_context('USERENV', 'SID');

在这里插入图片描述

在实战中的建议：

  1. 推荐使用Spring指定的ISOLATION_DEFAULT
  2. 未来实战中，并发访问情况很低，如果真遇到并发问题，可以使用乐观锁 Hibernate(JPA)

传播属性(propagation)

概念：描述了事务嵌套之间的特征（嵌套：指的是一个大的事务中，包含了若干个小的事务）
问题：大事务中融入了很多小的事务，他们彼此影响，最终就会导致外部大的事务，丧失了事务的原子性。
举例：比如在A事务里面嵌套着B、C两个事务，当B事务完成之后提交，随后运行C事务，若C事务产生异常，则会回滚，然后A事务也会回滚，但是B事务已经提交成功，无法再回滚了。

传播事务的值及其用法：

传播属性的值外部不存在事务外部存在事务用法备注
REQUIRED开启新的事务融合到外部事务中@Transactional(propagation = Propagation.REQUIRED)增删改方法
SUPPORTS不开启事务融合到外部事务中@Transactional(propagation = Propagation.SUPPORTS)查询方法
REQUIRES_NEW开启新的事务挂起外部事务，创建新的事务@Transactional(propagation = Propagation.REQUIRES_NEW)日志记录方法中
NOT_SUPPORTED不开启事务挂起外部事务@Transactional(propagation = Propagation.NOT_SUPPORTED)及其不常用
NEVER不开启事务抛出异常@Transactional(propagation = Propagation.NEVER)及其不常用
MANDATORY抛出异常融合到外部事务中@Transactional(propagation = Propagation.MANDATORY)及其不常用

Spring为我们制定的传播属性的默认值是 REQUIRED

只读属性(readOnly)

针对于只进行查询操作的业务方法，可以加入只读属性，提高运行效率。

@Transactional(readOnly = true)

超时属性(timeout)

指定了事务等待的最长时间。

  1. 为什么要进行等待？
    答： 当前事务访问数据时，有可能访问的数据被事务进行加锁的处理，那么此时本事务就必须等待。

  2. 等待时间是以秒为单位的

  3. 使用方法：

    @Transactional(timeout = 2)

  4. 默认值：-1（最终由对应的数据库决定）

异常属性

Spring 在对事务处理过程中，如果程序抛出异常，会进行自动回滚。
默认请况下是当抛出RuntimeException及其子类的时候，会回滚；
而当抛出Exception时不会回滚，会直接提交。

如果想要改变，可以指定以下两个属性rollbackFor = {}和noRollbackFor = {}

@Transactional(rollbackFor = {Exception.class})  //注意是class字节码

总结

使用建议：

  1. 隔离属性 默认值
  2. 传播属性 Required(默认值) 增删改 Supports 查询操作
  3. 只读属性 readOnly false 增删改 true 查询操作
  4. 超时属性 默认值 -1
  5. 异常属性 默认值
@Transactional //增删改操作
@Transactional(propagation=Propagation.SUPPORTS,readOnly=true)  //查询操作

基于标签的事务配置方式

完整配置如下：（只是把原来的<tx:annotation-driven>标签换掉了）

<?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:context="http://www.springframework.org/schema/context"
       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/context
        http://www.springframework.org/schema/context/spring-context.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/tx/spring-tx.xsd">

    <!--配置数据库连接池-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydata"/>
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>

    <!--配置SqlSessionFactoryBean-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="factoryBean">
        <!--指定DataSource数据库连接池-->
        <property name="dataSource" ref="dataSource" />
        <!--给实体类设置别名-->
        <property name="typeAliasesPackage" value="com.prince.entity" />
        <!--设置mapper.xml的文件路径-->
        <property name="mapperLocations">
            <list>
                <value>mapper/*Mapper.xml</value>
            </list>
        </property>
    </bean>

    <!--配置MapperScannerConfigurer-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" id="configurer">
        <!--SqlSessionFactoryBean-->
        <property name="sqlSessionFactoryBeanName" value="factoryBean" />
        <!--指定Dao接口所在的包-->
        <property name="basePackage" value="com.prince.dao" />

    </bean>

    <!--上面是Spring整合Mybatis-->

    <!--额外功能-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">
        <!--传入dataSource数据库连接池-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--创建UserService对象-->
    <bean class="com.prince.service.UserServiceImpl" id="userService">
        <!--Spring与Mybatis整合的时候会创建一个UserDao，直接把这个UserDao注入即可-->
        <property name="userDao" ref="userDao"/>
    </bean>

    <!--事务属性-->
    <tx:advice transaction-manager="dataSourceTransactionManager" id="txAdvice">
        <tx:attributes>
            <!--相当于给login()方法加入@Transactional注解-->
            <tx:method name="login" propagation="SUPPORTS" read-only="true"/>
            <!--相当于给insert()方法加入@Transactional注解-->
            <tx:method name="insert"  />
        </tx:attributes>
    </tx:advice>

    <!--组装切面-->
    <aop:config>
        <aop:pointcut id="pc" expression="execution(* com.prince.service.UserServiceImpl.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"/>
    </aop:config>

</beans>

踩坑：一定要导入AOP编程的3个依赖spring-aop、aspectjrt、aspectjweaver，否则会报错！！！！

实战中的建议：

随着业务功能的增加，方法会越来越多，那么<tx:advice>里面的<tx:method>标签页会越来越多。
解决方案：

<!--事务属性-->
<tx:advice transaction-manager="dataSourceTransactionManager" id="txAdvice">
    <tx:attributes>
        <tx:method name="modify*"/>	<!--所有的增删改方法以modify开头，加上通配符*可以匹配所有以modify开头的方法-->
        <tx:method name="*" propagation="SUPPORTS" read-only="true"/>  <!--剩下的查询方法，方法名可以是任意-->
    </tx:attributes>
</tx:advice>

<!--组装切面-->
<aop:config>
    <!--所有的业务类都放在service包下，匹配所有的方法-->
    <aop:pointcut id="pc" expression="execution(* com.prince.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"/>
</aop:config>

ng-aop、aspectjrt、aspectjweaver，否则会报错！！！！==

实战中的建议：

随着业务功能的增加，方法会越来越多，那么<tx:advice>里面的<tx:method>标签页会越来越多。
解决方案：

<!--事务属性-->
<tx:advice transaction-manager="dataSourceTransactionManager" id="txAdvice">
    <tx:attributes>
        <tx:method name="modify*"/>	<!--所有的增删改方法以modify开头，加上通配符*可以匹配所有以modify开头的方法-->
        <tx:method name="*" propagation="SUPPORTS" read-only="true"/>  <!--剩下的查询方法，方法名可以是任意-->
    </tx:attributes>
</tx:advice>

<!--组装切面-->
<aop:config>
    <!--所有的业务类都放在service包下，匹配所有的方法-->
    <aop:pointcut id="pc" expression="execution(* com.prince.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"/>
</aop:config>
mp-ui
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSM 框架整合教程：二、Spring-尚硅谷学习笔记 2022 年
09-08
本教程将深入探讨Spring框架的核心概念及其在SSM整合中的作用，结合尚硅谷2022年的学习笔记，为开发者提供一份详尽的指南。 **一、Spring框架简介** Spring是一款开源的Java平台，它提供了全面的企业级应用开发解决...
java持久层框架分析
xseven
09-08 522
一. 目前在java应用程序开发中,使用广泛的,开源的持久层框架是Hibernate 和 Ibatis 。 ibatis和hibernate都是ORM解决方案,不同的是两者各有侧重。Hibernate提供了Java对象到数据库表之间的直接映射,开发者无需直接涉及数据库操作的实现细节,实现了一站式的ORM解决方案。而ibatis则采取了另一种方式,即提供Java对象到SQL（面向参数和结...
java框架--持久化层
weixin_42325110的博客
01-13 1936
一、持久化层 1. 将内存中的数据保存到关系型数据库的过程称为持久化。 2. 持久化层的构成 事务（ACID） A：atomicity原子性。一个事务是一个不可分割的工作单位，事务中包括的操作要么都做，要么都不做。 C: consistency一致性。事务必须是使数据库从一个一致状态变到另一个一致性状态。 I: isolation隔离性。一个失误的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。 D: durability持久性。持久性
java的持久层_2020年，java持久层怎么选择？
weixin_36071439的博客
02-20 278
到2020了，做持久层的框架有很多，有orm系utils系列。orm系列的代表有：hibernate，eclipseLink，topLink；utils系列的代表有：mybatis，dbUtils，jdbcTemplate等；至于 jpa，它只是一个规范标准，并非具体框架，不等同于 spring-data-jpa；同时 spring-data-jpa 也不是 jpa 的具体实现，它只是 jpa 规...
spring 读写分离和多数据源配置的详解
做你想做的人，没有时间的限制，只要愿意，什么时候都可以start。
04-03 1322
说明:1。我所写的是建立在查看学习其他人所写的基础之上的，如果有相似的代码，恳求请原谅.2。本方法完全无侵入式。但需要友好的命名约定。3。读写分离和多数据源是建立在主从数据库同步的基础上，请查看我的另一篇文章:主从同步。4。为什么要读写分离，读写分离到什么地步？    为什么要读写分离？因为数据表明，一个application，查的数量非常多，增删改的数量非常小。所以为了均衡压力，初步可以让增删改...
SSM 框架整合教程-尚硅谷学习笔记 2022 年
08-17
通过阅读"SSM框架整合教程——尚硅谷学习笔记 2022 年.md"或"SSM框架整合教程——尚硅谷学习笔记 2022 年.pdf"，你可以深入学习如何配置SSM环境，创建基本的CRUD操作，以及如何优化和扩展SSM应用。这些知识点不仅...
springmvc学习笔记-springmvc整合mybatis.zip
最新发布
05-10
而 MyBatis 是一个轻量级的持久层框架，它提供了方便的 SQL 执行和结果映射功能。 1. **SpringMVC 概述** - SpringMVC 是基于 Servlet 的 MVC 框架，它简化了 Java Web 开发中的请求处理和视图渲染。 - 核心组件...
Spring Boot学习笔记
03-21
总结，Spring Boot学习笔记涵盖了Thymeleaf模板引擎的使用，如何实现国际化，以及如何将MyBatis和JDBC整合到Spring Boot应用中，这些都是在构建现代Java后端应用时不可或缺的技术。通过深入理解并掌握这些知识点，...
java三大框架学习笔记总结 新手必看
08-14
本篇学习笔记总结将深入探讨这三个框架的核心概念、使用方法以及它们之间的协作关系。 Struts是MVC（Model-View-Controller）架构模式的一个实现，主要用于控制应用程序的流程。它的主要组件包括Action、ActionForm...
Java持久层框架
热门推荐
龚道松
07-29 1万+
所谓"持久"就是将数据保存到可掉电式存储设备中以便今后使用，简单的说，就是将内存中的数据保存到关系型数据库、文件系统、消息队列等提供持久化支持的设备中。持久层就是系统中专注于实现数据持久化的相对独立的层面。 持久层设计的目标包括： - 数据存储逻辑的分离，提供抽象化的数据访问接口。 - 数据访问底层实现的分离，可以在不修改代码的情况下切换底层实现。 - 资源管理和调度的分离，在数据访问层实...
Java专家之路（二）---数据访问和数据持久化框架的总结
softwareCraftsman
12-20 1万+
Java数据访问和持久化SQL 方案一JDBC 什么是JDBC 架构图 JDBC规范下载链接 JAVA使用JDBC访问数据库的步骤 实例练习 方案二JdbcTemplate jdbcTemplate是什么 应用场景 实例操作 方案三ORM ORM是什么 为什么需要ORM 主要是解决jdbc的各种问题 ORM的优势 ORM带来了什么样的问题 ORM是否非得使用 ORM的实现原理思路 有哪些ORM方案可
JavaEE框架学习笔记——SpringMVC篇
齐天小圣^O^ 的博客
03-22 452
一、SpringMVC的注解开发 配置DispatchServlet-Servlet.xml <!-- 1.配置注解扫描位置 --> <context:component-scanbase-package="com.gyf.backoffice.web.controller"/> <!-- 2. 配置处理器映...
【MyBatis】Java 持久层框架入门与实践 | 学习笔记
Fxtack的博客
08-21 304
MyBatis 学习笔记 | 一篇入门到实践 导读 本篇文章将带领读者学习 MyBatis 框架。开始文章简述 MyBatis。之后将手把手的搭建一个简单的 MyBatis 框架的测试，先跑起来。随后将出于这个建的测试讲解 MyBatis 框架中重要的几个配置文件。然后对于数据库常用的增、删、查、改操作在 MyBatis 中的进行实现，并讨论一些 Java 中集合在 MyBatis 中的配置与应用。剩下的时间将讲解一些细节而常用的知识。 文中代码中嵌有大量的注释，这些注释对于理解和学习 MyBatis 有
Java持久层框架整理
MyHeartWillGoOn明博客
05-23 1849
一：MyBatis框架 MyBatis介绍 Batista本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis。 MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。 Myb..
【Spring】对持久层技术的整合
diaolin2115的博客
08-15 102
一、持久层技术 二、JdbcTemplate 开发步骤： 1. 导入相关的jar包 2. 配置连接池(数据源) 将参数设置到属性文件中: 3. 创建表 4. 编写实体类 5. Dao层实现 5.1 继承JdbcDaoSupport 5.2 直接注入JdbcTmplate 6. 测试 JdbcTemplate 的CRUD(待整...
一个叫Spring的框架，“SSH”框架之总结（Hibernate、Spring、SpringMVC）
wenqiang612的博客
07-29 3078
通过学习一个叫Hibernate（冬眠）的框架后，进而学习一个叫Spring（春）的框架！！ 在hibernate中我们主要是整合了DAO层对数据库的CRUD操作，而Spring主要是是为了让我们对标准三层架构（MVC）进行整合！ ps：一下是一些我的总结(可能会有点乱，具体可以参看个人项目代码) ps：代码网盘链接：http://pan.baidu.com/s/1c2ISyjA 密码：bx
javaEE之mybatis复习笔记
qq_41453750的博客
02-26 156
#三层架构 1、表现层：它是用于展示数据的；业务层：处理业务需求；持久层：是数据库交互的； #持久层解决方案 持久层技术解决方案有哪些技术:1、jdbcj技术:Connection、PrepareStatement、ResultSet；2、Spring jdbcTemplate：spring对JDBC简单封装；3、Apache DBUtils：也是对jdbc的简单封装，但JDBC、Spring J...
Spring基础-整合持久层
WangXiong的博客
04-28 138
1、持久层
Spring框架学习笔记：从基础到进阶
"这是关于Spring框架的学习笔记，涵盖了Spring的基本概念、优势、体系结构以及快速入门的步骤。笔记旨在帮助读者更方便地学习和理解Spring框架的使用。" Spring框架是Java开发领域中广泛使用的开源框架，它以IoC...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值