Spring整合Mybatis、redis的Hello-World程序

最新推荐文章于 2024-03-19 13:53:41 发布
最新推荐文章于 2024-03-19 13:53:41 发布
阅读量237 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37993487/article/details/80957622
版权

Spring+Redis

1.首先redis服务器要处于开启状态
2.redis maven依赖

<!-- redis -->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.8.9.RELEASE</version>
</dependency>

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

<!-- spring -->
// 省略

3.配置文件：spring-redis.xml (具体文件的路径由实际决定)，如果没有设置密码那么就删去有关密码的部分

<?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:p="http://www.springframework.org/schema/p"
       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">

    <context:property-placeholder location="classpath:redis/redis.properties" ignore-unresolvable="true"/>
    <context:component-scan base-package="com.dadagum.util"/>

    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig"
          p:maxIdle="${redis.maxIdle}"
          p:maxWaitMillis="${redis.maxWaitMillis}"
          p:maxTotal="${redis.maxTotal}"
          p:numTestsPerEvictionRun="${redis.numTestsPerEvictionRun}"
          p:timeBetweenEvictionRunsMillis="${redis.timeBetweenEvictionRunsMillis}"
          p:testOnBorrow="${redis.testOnBorrow}"
          p:minEvictableIdleTimeMillis="${redis.minEvictableIdleTimeMillis}"
          p:testWhileIdle="${redis.testWhileIdle}"/>

    <bean id="jedisConnFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:hostName="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:poolConfig-ref="poolConfig"
          p:timeout="${redis.timeout}"/>

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
          p:connectionFactory-ref="jedisConnFactory" >
        <property name="keySerializer">
            <bean
                    class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <property name="hashKeySerializer">
            <bean
                    class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <property name="valueSerializer">
            <bean
                    class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
        </property>
        <property name="hashValueSerializer">
            <bean
                    class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
        </property>
    </bean>
</beans>

4.redis.properties文件

#redis连接服务端配置
redis.host=127.0.0.1
redis.port=6379
redis.password=test

#客户端超时时间
redis.timeout=2000
#最大空闲数
redis.maxIdle=10
#控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性
redis.maxTotal=10
#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
redis.maxWaitMillis=1000
#连接的最小空闲时间 默认1800000毫秒(30分钟)
redis.minEvictableIdleTimeMillis=300000
#每次释放连接的最大数目,默认3
redis.numTestsPerEvictionRun=1024
#逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
redis.timeBetweenEvictionRunsMillis=30000
#是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
redis.testOnBorrow=false
#在空闲时检查有效性, 默认false
redis.testWhileIdle=false

5.redisUtil(作为例子只写有一小部分) 

package com.dadagum.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 设置缓存的失效时间
     * @param key
     * @param time
     * @return
     */
    public boolean expire(String key, long time){
        try {
            if (time > 0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 根据key获取过期时间
     * @param key
     * @return
     */
    public long getExpire(String key){
        return  redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e){
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 删除某些缓存
     * @param key
     */
    @SuppressWarnings("unchecked")
    public void deleteK(String ... key){
        if (key == null || "".equals(key)) return;
        if (key.length == 1) {
            redisTemplate.delete(key[0]);
        } else {
            redisTemplate.delete(CollectionUtils.arrayToList(key));
        }
    }

    /**
     * 获取某个缓存
     * @param key
     * @return
     */
    public Object getValue(String key){
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入，默认失效时间为无限长
     * @param key
     * @param value
     * @return
     */
    public boolean setValue(String key, Object value){
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 设置缓存并且设置时间
     * @param key
     * @param value
     * @param time
     * @return
     */
    public boolean setValue(String key, Object value, long time){
        try {
            if (time > 0){
                redisTemplate.opsForValue().set(key, value, time);
            } else {
                setValue(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

}

6.测试

    @Test
    public void testConnection(){
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring-redis.xml");
        RedisUtil redisUtil = (RedisUtil) context.getBean("redisUtil");
        redisUtil.setValue("hello", "world");
        System.out.println(redisUtil.getValue("hello"));
    }

Spring+Mybatis

1.使用Spring就将原本由mybatis配置交由spring管理了，十分方便 

<?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:p="http://www.springframework.org/schema/p"
       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">

    <!-- 数据库数据源 -->
    <context:property-placeholder location="classpath:sql/jdbc.properties" ignore-unresolvable="true"/>
    <bean id = "dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close"
          p:driverClassName="${jdbc.driver}"
          p:url="${jdbc.url}"
          p:username="${jdbc.username}"
          p:password="${jdbc.password}"/>

    <!-- mybatis -->
    <!-- sql session 实例 -->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionFactoryBean"
          p:typeAliasesPackage="com.dadagum.bean"
          p:dataSource-ref="dataSource"
          p:mapperLocations="classpath:com/dadagum/mapper/*.xml" />

    <!-- mapper 扫描 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" p:basePackage="com.dadagum.mapper"/>

</beans>

2.创建mapper
①创建mapper接口 (使用xml的方式而不使用注解；如果使用注解直接可以在接口的方法上添加@insert等注解) 

package com.dadagum.mapper;

import com.dadagum.bean.UserInfo;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;

import java.util.List;
import java.util.Set;

public interface UserInfoMapper {

    /**
     * 增加一个用户
     * @param userInfo
     * @return
     */
    public int addUser(UserInfo userInfo);

    /**
     * 得到所有的用户信息
     * @return
     */
    public List<UserInfo> getUserInfo();

    /**
     * 根据用户的名称得到用户的密码
     * @return
     */
    public String getPasswordByUserName(String username);

    /**
     * 根据用户的名称得到用户信息中的盐值
     * @param username
     * @return
     */
    public String getSaltByUserName(String username);
}

②编写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.dadagum.mapper.UserInfoMapper">
    <select id="getUserInfo" resultType="UserInfo">
        select * from userinfo
    </select>

    <select id="selectUser" parameterType="_int" resultType="UserInfo">
        select * from userinfo where userId = #{id}
    </select>

    <insert id="addUser" parameterType="UserInfo">
        insert into userInfo values(null, #{userAccount}, #{userPassword}, null, null, #{salt})
    </insert>

    <select id="getPasswordByUserName" parameterType="string" resultType="string">
        select userPassword from userinfo where userAccount = #{username}
    </select>

    <select id="getSaltByUserName" parameterType="string" resultType="string">
        select salt from userinfo where userAccount = #{username}
    </select>
</mapper>

3.配置pom.xml
默认会在resource资源总目录中寻找xml文件,但是我们的mapper的xml文件写在java的目录下,因此要在pom.xml的built标签中加上

<!-- to let mybatis find my mapper -->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>

这样子就可以正确找到我们编写mapper的xml文件了
4.测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring/spring-dao.xml")
public class MybatisSpringTest {

    @Autowired
    private UserInfoMapper mapper;

    @Test
    public void testSelect(){
        System.out.println(mapper.getUserInfo());
    }
}
dadagum
关注
专栏目录
myBatis整合redis
javahhhhhh的博客
12-09 1901
redis分布式缓存，mybatis提供了一个针对cache接口的redis实现类，该类存在mybatis-redis包 中 pom文件 <dependency> <groupId>org.mybatis.caches</groupId> <artifactId>mybatis-redis</artifactId> <version>1.0.0-beta2</version> </dependency> 2
SpringBoot整合配置Mybatis、Redis
qq_41797857的博客
04-09 564
通过SpringBoot配置整合Mybatis、Redis 学习SpringBoot框架，实操下整合配置Mybatis、redis SpringBoot配置 步骤： 首先创建Maven项目后在pom.xml文件配置Springboot依赖包（可在Springboot官方查询相关入门教程：入口） <?xml version="1.0" encoding="UTF-8"?> <p...
redis整合spring mybatis --缓存方案
热门推荐
劝君与我同风起，扶摇直上九万里
04-05 2万+
上一篇总结了redis sentinel（哨兵方案）的配置流程，本篇就redis整合ssm框架进行说明。目前，大多数公司用redis主要做缓存用，对于那些不常变动的数据来说，我们将其缓存在redis中，可以大大减少数据库的压力。
redis mybatis spring整合
alex_u3的博客
06-30 7132
最近想在框架里面加入redis，替换原因呢其实也没有，就是单纯的想替换掉 ---维基百科：redis介绍 一般开发中用户状态使用session或者cookie，两种方式各种利弊。 Session:在InProc模式下容易丢失，并且引起并发问题。如果使用SQLServer或者SQLServer模式又消耗了性能 Cookie则容易将一些用户信息暴露，加解密同样也消耗了
MyBatis与Redis
yongqi_wang的博客
05-27 1万+
一。MyBatis    1.简介 ① MyBatis是一个持久层框架，完成的是对数据库的访问和操作；（CRUD） ② 它解决了JDBC对数据库的操作与访问过程中存在的问题，是对原有JDBC技术的封装 ③ MyBatis解决JDBC的问题 【1】虽然JDBC操作数据库的方式很直观，但其核心就是对于数据库的操作。多个方法间存在大量的冗余 【2】基于Java中面向对象的基本思想，所以我们会将查询出...
MyBatis 使用 Redis 缓存
很酷的站长的博客
01-19 956
在上一文中，我们介绍了 MyBatis 的多级缓存。MyBatis 的二级缓存可在多个会话中共享缓存，但是这也加大了内存的使用空间，如果二级缓存空间占有量过多势必会导致程序运行空间的不足，因此我们需要将二级缓存转移到专业的缓存服务器上。Redis 是一个高性能的 kv 数据库，被广泛的使用在缓存服务上，MyBatis 项目开发者提供了 Redis 缓存的实现。本小节我们将一起来学习如何在 MyBatis 中集成 Redis 缓存。
Mybatis-Plus+SpringBoot框架
gggikun的博客
12-17 997
目录SpringBoot 提供了一种快速使用 Spring 的方式，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。2014 年 4 月，Spring Boot 1.0.0 发布，并作为 Spring 的顶级项目之一。步骤： 定义 Controller： 编写引导类： controller 类必须是 Application 的所在包的类或者子包的类。 执行 main 方法，启
spring boot 完整版整合mybatis,rabbitmq,freemarker,redis等
10-19
### Spring Boot 整合 MyBatis、RabbitMQ、Freemarker、Redis 等技术栈详解 #### 一、Spring Boot 基础配置与动态属性解析 在 Spring Boot 应用中，配置文件（如 `application.properties` 或 `application.yml`）...
Java后端学习日记（三）：Springboot整合Mybatis-Plus并简单地CRUD
Yuc0114的博客
09-22 500
专栏目录 Java后端学习日记（一）：第一个Springboot应用——Hello World! Java后端学习日记（二）：POJO的基本概念，编写，转化和简化 项目源码同步更新中 前言 在前两篇文章中我们学习了hello world，认识了POJO，但是这些好像离做一个网站还很远。没关系，接下来我们就开始接触CRUD。 本文假定你已经： 熟悉MySQL 看过本专栏的前两篇或熟悉Springboot+Lombok 导航专栏目录前言Mybatis-Plus整合Mybatis-Plus1. 依赖&amp
spring-boot-mybatis.jar
08-26
springboot项目,集成了常用的技术,导入sql脚本即可运行,后续如需要集成别的技术，可私信或者评论下方留言，框架如有不妥之处，可提出。
Redis整合Mybatis
air_stalh的博客
07-12 939
将Mybatis的缓存修改成redis缓存 将缓存和数据库分开
mybatis集成redis
随风飘絮
08-06 335
4. WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。3. SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。1. LRU – 最近最少使用的:移除最长时间不被使用的对象。2. FIFO – 先进先出:按对象进入缓存的顺序来移除它们。1，在同一namespace下。......
mybatis使用redis作为自定义缓存的配置
青衣小卒的博客
12-06 5403
配置mybatis使用redis作为自定义缓存mybatis自身的缓存做的并不完美，但它提供了使用自定义缓存的机会，我们可以选择使用我们喜欢的自定义缓存，下面将介绍一下，使用redis作为mybatis的自定义缓存的具体步骤。 redis和mybatis的下载以及使用这里就不多介绍了（网上都可以学到）1.首先，要想使用mybatis自定义缓存，就必须让自定义缓存类实现mybatis提供的Cache
mybatis整合redis
Soul717的博客
12-20 1636
mybatis整合redis步骤 1.添加redis相关依赖           redis与spring的整合依赖           log4j2配置：Log4j2 + Slf4j            jackson     2.spring + redis 集成实现缓存功能(与mybatis无关)           添加两个redis的配置文件，并将redis.properties和s...
mybatis阶段redis的使用
youxizaixian123的博客
10-28 305
mybatis阶段redis的使用
Mybatis整合Redis实现二级缓存，事件分发流程图，2024年春招前端面试题
最新发布
m0_63174529的博客
03-19 833
jedisredis存储数据需要借助序列化器，序列化器的数据存储又要依赖于json的依赖jar包，因此还要导入json的相关依赖2.建立redis.propertiesredis.hostName=192.168.95.110虚拟机ipredis.password=root123密码3.建立applicationContext-redis.xml文件放1. 引入properties配置文件2. redis连接池配置最大空闲数连接池的最大数据库连接数最大建立连接等待时间。
mybatis+redis使用
qq_40453972的博客
08-26 1692
mybatis缓存机制和redis
mybatis缓存 redis实现
mrdu_somefun的博客
01-13 689
最近项目需要针对mybatis查询加入缓存，使用redis，于是上网查找mybatis缓存 redis实现的相关文章，有很多关于mybatis redis缓存的介绍以及mybatis Cache接口的redis实现代码，但内容都是一致，看得出都转载某一人的手笔，虽然提供的代码逻辑是正确的，但是在项目应用中都存在问题。请小心使用！    为什么网上流传的mybatis redis实现代码有问题
Mybatis整合Redis实现分布式缓存
sunshineKay的博客
06-28 1842
Mybatis自带二级缓存底层数据结构为HashMap，无法适用于分布式环境。 本文要点： 1.Mybatis整合Redis实现分布式缓存 2.查看自定义缓存实现类RedisCache及相关源码，了解Redis在实现MyBatis二级缓存中的执行工作流 (更多二级缓存知识点可参考MyBatis二级缓存)，存储类型（hash）等 1.Mybatis整合Redis实现分布式缓存 A.引入Mybatis整合Redis依赖Jar包 <dependency> ..
Spring Boot整合MyBatis+MyBatis-Plus实战教程与Maven依赖配置
本文将详细介绍如何在Spring Boot项目中整合MyBatis和MyBatis-Plus，这是一个实用且常见的话题，适合对这两个技术栈感兴趣的开发者。Spring Boot默认倾向于使用Spring Data JPA，但作者个人更倾向于MyBatis的灵活性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值