spring---- （4）事务&RedisTemplate

参考视频

https://www.bilibili.com/video/BV1yq4y1N78E?spm_id_from=333.337.search-card.all.click

事务回顾

事务的作用

1. 当数据库操作序列中个别操作失败时，提供一个方式使数据库状态恢复到正常状态（A）,保障数据库即使在异常状态下任然能够保持数据一致性（C）(要么操作前状态，要么操作后状态)
2. 当出现并发访问数据库时，在多个访问间进行相互隔离，防止并发访问操作结果互相干扰（I）

事务特征（ACID）

• 原子性（Atomicity）指事务是一个不可分割的整体，其中的操作要么全执行或全部执行
• 一致性（Consistency）事务前后数据的完整性必须保持一致
• 隔离性（Isolation）事务的隔离性是多个用户并发访问数据库时，数据库为每个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离
• 持久性（Durability）持久性是指一个事务一旦被提交，他对数据库中的数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响
  
  
  

事务管理

Spring事务核心对象

用于解决业务层事务问题

PlatformTransactionManager

TransactionDefinition

TransactionStatus

案例环境

编程式事务

    @Autowired
    private DataSource dataSource;

    public void transfer(Integer outId,Integer inId,Double money){
        //开启事务
        PlatformTransactionManager ptm = new DataSourceTransactionManager(dataSource);
        //事务定义
        TransactionDefinition td = new DefaultTransactionDefinition();
        //事务状态
        TransactionStatus ts = ptm.getTransaction(td);

        //提交事务
        accountDao.outMoney(outId,money);
        int i = 1/0;
        accountDao.inMoney(inId,money);

        ptm.commit(ts);
    }

声明式事务（XML）

基于aop的事务控制 spring给出了专门的名称空间

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"/>
</bean>

<!--定义事务管理的通知类-->
<tx:advice id=“txAdvice” transaction-manager="txManager">
	<!--定义控制的事务-->
	<tx:attributes>
		<!--全盘读写事务-->
		<tx:method name="*" read-only="false"/> 
		<!--给度的方法指定读事务-->
		<tx:method name="get*" read-only="true"/> 
		<tx:method name="find*" read-only="true"/>
	</tx:attributes>
</tx:advice>
<aop:config>
	<aop:pointcut id="pt" expression="execution(* com.itheima.service.*Service.*(..))">
	<aop:advisor advice-ref="txAdvice" pointcut-ref="pt" />
</aop:config>

声明式事务（注解）

一般声明式注解是添加在接口上，不会添加在实现类上

事务传播行为

模板对象

• TransactionTemplate
• JdbcTemplate
• RedisTemplate
• RabbitTemplate
• JmsTemplate
• HibernateTemplate
• RestTemplate

redisTemplate

测试redis是否可连接

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.1</version>
</dependency>

@Test{
	Jedis jedis = new Jedis(192.168.1.20,6379);
	jedis.set("name","itheima");
	jedis.close();
}

需要确保redis服务器设置protected-mode no
cat redis.conf | grep -v "#" | grep -v "^$"

RedisConfig

package com.itheima.config;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@PropertySource("redis.properties")
public class RedisConfig {

    @Value("${redis.host}")
    private String hostName;

    @Value("${redis.port}")
    private Integer port;

//    @Value("${redis.password}")
//    private String password;

    @Value("${redis.maxActive}")
    private Integer maxActive;
    @Value("${redis.minIdle}")
    private Integer minIdle;
    @Value("${redis.maxIdle}")
    private Integer maxIdle;
    @Value("${redis.maxWait}")
    private Integer maxWait;



    @Bean
    //配置RedisTemplate
    public RedisTemplate createRedisTemplate(RedisConnectionFactory redisConnectionFactory){
        //1.创建对象
        RedisTemplate redisTemplate = new RedisTemplate();
        //2.设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //3.设置redis生成的key的序列化器，对key编码进行处理
        RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
        //4.返回
        return redisTemplate;
    }

    @Bean
    //配置Redis连接工厂
    public RedisConnectionFactory createRedisConnectionFactory(RedisStandaloneConfiguration redisStandaloneConfiguration,GenericObjectPoolConfig genericObjectPoolConfig){
        //1.创建配置构建器，它是基于池的思想管理Jedis连接的
        JedisClientConfiguration.JedisPoolingClientConfigurationBuilder builder = (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder)JedisClientConfiguration.builder();
        //2.设置池的配置信息对象
        builder.poolConfig(genericObjectPoolConfig);
        //3.创建Jedis连接工厂
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(redisStandaloneConfiguration,builder.build());
        //4.返回
        return jedisConnectionFactory;
    }

    @Bean
    //配置spring提供的Redis连接池信息
    public GenericObjectPoolConfig createGenericObjectPoolConfig(){
        //1.创建Jedis连接池的配置对象
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        //2.设置连接池信息
        genericObjectPoolConfig.setMaxTotal(maxActive);
        genericObjectPoolConfig.setMinIdle(minIdle);
        genericObjectPoolConfig.setMaxIdle(maxIdle);
        genericObjectPoolConfig.setMaxWaitMillis(maxWait);
        //3.返回
        return genericObjectPoolConfig;
    }


    @Bean
    //配置Redis标准连接配置对象
    public RedisStandaloneConfiguration createRedisStandaloneConfiguration(){
        //1.创建Redis服务器配置信息对象
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        //2.设置Redis服务器地址，端口和密码（如果有密码的话）
        redisStandaloneConfiguration.setHostName(hostName);
        redisStandaloneConfiguration.setPort(port);
//        redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
        //3.返回
        return redisStandaloneConfiguration;
    }

}

redis.properties

# redis服务器主机地址
redis.host=192.168.40.130
#redis服务器主机端口
redis.port=6378

#redis服务器登录密码
#redis.password=itheima

#最大活动连接
redis.maxActive=20
#最大空间连接
redis.maxIdle=10
#最小空闲连接
redis.minIdle=0
#最大等待时间
redis.maxWait=-1

package com.itheima.service.impl;


import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
@Service("accountService")
public class AccountServiceImpl implements AccountService {

    @Autowired
    private RedisTemplate redisTemplate;

    public void save(Account account) {
    }

    public void changeMoney(Integer id, Double money) {
        //等同于redis中set account:id:1 100
        redisTemplate.opsForValue().set("account:id:"+id,money);
    }

    public Double findMondyById(Integer id) {
        //等同于redis中get account:id:1
        Object money = redisTemplate.opsForValue().get("account:id:" + id);
        return new Double(money.toString());
    }
}
//        redisTemplate.type()
//        redisTemplate.persist()
//        redisTemplate.move()
//        redisTemplate.hasKey()
//        redisTemplate.getExpire()
//        redisTemplate.expire()
//        redisTemplate.delete()
//        redisTemplate.rename();
//        数据类型
//        redisTemplate.opsForValue().;
//        redisTemplate.opsForHash().;
//        redisTemplate.opsForList().;
//        redisTemplate.opsForSet().;
//        redisTemplate.opsForZSet();
//
//		  阻塞
//        redisTemplate.boundValueOps().;
//		  主从
//        redisTemplate.slaveOf();
//        redisTemplate.slaveOfNoOne();
//		  集群
//        redisTemplate.opsForCluster()

事务底层原理解析