springboot融合redis、jpa、tkmybatis、jdbc

最新推荐文章于 2023-08-15 01:34:41 发布
最新推荐文章于 2023-08-15 01:34:41 发布
阅读量274 收藏
点赞数 1
分类专栏： 第三阶段 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yang_zhong_rong/article/details/119493723
版权

springboot整合文件上传

@Controller
public class FileController {
    @RequestMapping("/uploadFile")
    public String uploadFile(@RequestParam("fileimage")MultipartFile file , @RequestParam("userid") String userid, HttpServletRequest request) throws IOException {

        String originalFilename = file.getOriginalFilename();

      String path=request.getContextPath();

       File file1=new File(path,originalFilename);

       file.transferTo(file1);

       return "index2";

   }
}

redis的简介

1.1、为什么使用redis?

（1）、解决应用服务器的cpu和内存压力

（2）、减少io的读操作，减轻io的压力

（3）、关系型数据库的扩展性不强，难以改变表结构

1.2、优点

（1）、nosql数据库没有关联关系，数据结构简单，拓展表比较容易

（2）、nosql读取速度快，对较大数据处理快

注意，非关系型数据库没有事务！

1.3、适用场景：

(1)、数据高并发的读写

（2）、海量数据的读写

（3）、对扩展性要求高的数据

1.4、不适场景：

（1）、需要事务支持（非关系型数据库）

（2）、基于sql结构化查询储存，关系复杂

1.5、Redis结构：

Redis是一个开源的key—value型数据库，支持string、list、set、zset和hash类型数据。对这些数据的操作都是原子性的，Redis为了保证效率会定期持久化数据。

1.6、使用场景：

（1）、配合关系型数据库做高速缓存

· 缓存高频次访问的数据，降低数据库io

· 分布式架构，做session共享

（2）、可以持久化特定数据。

· 利用zset类型可以存储排行榜

· 利用list的自然时间排序存储最新n个数据

1.7、Linux下redis：

（1）、redis目录：usr/local/bin

（2）、linux下redis常用命令：

（2.1）、redis-benchmark：性能测试工具

（2.2）、redis-server：启动redis服务器

（2.3）、redis-cli：启动redis客户端，操作入口

1.8、Redis基础知识

（1）、端口：6379

（2）、默认16个数据库，下标从0开始

（3）、单线程：redis是单线程+io多路复用：检查文件描述的就绪状态

springboot融合Redis

在yml中Redis的一些基本配置

#=========redis基础配置=========
spring.redis.database=0
spring.redis.host=192.168.139.131
spring.redis.port=6379
# 连接超时时间 单位 ms（毫秒）
spring.redis.timeout=3000
#=========redis线程池设置=========
# 连接池中的最大空闲连接，默认值也是8。
spring.redis.pool.max-idle=200
#连接池中的最小空闲连接，默认值也是0。
spring.redis.pool.min-idle=200
# 如果赋值为-1，则表示不限制；pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
spring.redis.pool.max-active=2000
# 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时
spring.redis.pool.max-wait=1000

1.导入springboot融合的Redis的依赖

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

2.在yml配置文件中配置相应的属性

spring:
  redis:
    database: 0
    host: localhost
    port: 6379
    timeout: 3000
    pool:
    max-idle: 200
    min-idle: 200
    max-active: 2000
    max-wait: 1000
  datasource:
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/company?characterEncoding=utf8
      username: root
      password: root
    type: com.alibaba.druid.pool.DruidDataSource
logging:
    level:
      com.qs.springboot4_redis.mapper: debug
mybatis:
  mapper-locations: classpath*:*Mapper.xml
  type-aliases-package: com.qs.demo.pojo

3.在启动程序中编写一个Redis实现类，用来json与object的互相转换

  //实例化一个对象,springboot取对象类型是HashMap,不是我们想你中的User类型，重新实例化，将它默认序列化类型修改一下
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        // key采用String的序列化方式
        template.setKeySerializer(new StringRedisSerializer());
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        // value序列化方式采用jackson
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

4.在业务层中di该类RedisTemplate<String, Object>

注意：自动装换的依赖在spring-boot-starter-web依赖中包含了

 @Autowired
 private RedisTemplate<String, Object> redisTemplate;

1.从Redis中取出数据，并主动装换为对象
    
     List<Users> list=(List<Users>)redisTemplate.opsForValue().get("userlist");

2.将对象自动以json格式更新Redis
    
    redisTemplate.opsForValue().set("userlist",list);

springboot融合tkmybatis

1.导入相应的依赖 mapper

 <!--        第三方github的mybatis:tkmybatis-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>

2.导入第三方的分页插件依赖 pageHelper

<!--        第三方后台分页插件-->
        <!--        4、pageHelper-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.12</version>
        </dependency>

3.编写dao接口只需要继承Mapper即可

public interface UserMapper extends Mapper<Users> {
    //Mapper包含了基本的增删改查的方法
}

注意导包：import tk.mybatis.mapper.common.Mapper;

4.在启动程序中加上mapper注解扫描

@MapperScan("com.qs.springtkmybatis.mapper")

5.测试tkmybatis基本的CRUD

  @Autowired
    private UserMapper userMapper;
    @Test
    void insertUsers() {
        Users users=new Users("18","6","6","6","6","6");
        userMapper.insertSelective(users);
    }
    @Test
    void delUsers() {
        Users users=new Users();
        users.setUserid("555");
        userMapper.deleteByPrimaryKey(users);
    }
    @Test
    void updateUsers() {
        Users users=new Users("18","66","56","66","66","666");
        userMapper.updateByPrimaryKeySelective(users);
    }

6.分页查询的测试

  • tkmybatis自己的分页
    //tkmybatis自己的分页  
	Users users=new Users();
        users.setUserid("18");
        userMapper.select(users);
        //userMapper.selectAll();
        int page=2;
       //tkmybatis
        RowBounds rowBounds=new RowBounds((page-1)*5,5);
       List<Users> users1 = userMapper.selectByRowBounds(new Users(), rowBounds);
        System.out.println(users1);

  • 第三方pagehelper插件的分页测试

    1.先设置开始页

    PageHelper.startPage(2,5);

    2.PageInfo pageInfo=new PageInfo<>(userMapper.selectAll());

     		PageHelper.startPage(2,5);
        PageInfo<Users> pageInfo=new PageInfo<>(userMapper.selectAll());
        System.out.println(pageInfo);
        System.out.println(pageInfo.getPages());//4  总页数
        System.out.println(pageInfo.getTotal());//20 总条数
        System.out.println(pageInfo.getPageNum());//2 第几页
        System.out.println(pageInfo.getPageSize());//5 每页几条
        System.out.println(pageInfo.getNextPage());//3 下一页
        System.out.println(pageInfo.getList());//数据springboot融合jpa

springboot融合jpa

1.导入依赖

   <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

2.在yml中可以配置jpa的日志

spring:
  datasource:
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/company?characterEncoding=utf8
      username: root
      password: root
    type: com.alibaba.druid.pool.DruidDataSource
  jpa:
    show-sql: true
    open-in-view: true

3.编写dao接口

注意：只需要继承JpaRepository<Users,String>类即可泛型里面左边的实体类类型Users，右边是主键类型String

jpa此处不用再主程序中实例化扫描这个接口，而tkmybatis需要

public interface UserDao extends JpaRepository<Users,String> {
    //JpaRepository<Users,String>中有基本的CRUD不需要自己写
}

4.jpa的实体类 以下为jpa的语法

@Entity
@Data
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "tb_users")//类名与数据库名不一致时，需要加这个
public class Users implements Serializable {
    @Id//声明此列是主键   
    private String userid;
    @Column(name = "username")//当字段名与数据库名不一致时可以加此注解
    private String username;
    private String pwd;
    private String status;
    private String phone;
    private String address;
}

5.测试CRUD

注意：jpa的添加和修改都是save方法

jpa会根据主键先查找一遍，如果有则修改，没有则是添加

    @Test
    void saveandUpdateUser() {
        Users users=new Users();
        users.setUserid("234");
        users.setStatus("vip");
        users.setUsername("shuhao6767");
        users.setPwd("666");
        users.setPhone("17277");
        users.setAddress("453");
        userDao.save(users);
    }
    @Test
    void delUser() {
        Users users=new Users();
        users.setUserid("234");
        users.setStatus("vip");
        users.setUsername("shuhao6767");
        users.setPwd("666");
        users.setPhone("17277");
        users.setAddress("453");
        userDao.delete(users);
    }
    @Test
    void findUser() {
        List<Users> all = userDao.findAll();
        System.out.println(all);

6.jpa的分页 1.PageRequest 2.Page 对比：tkmybatis的分页 1.PageHelper 2.PageInfo

 //测试分页
    @Test
    void findpageUser() {
        PageRequest request=PageRequest.of(2,3);
        Page<Users> page=userDao.findAll(request);
        for (Users users : page) {
            System.out.println(users);
        }
        System.out.println(page.getTotalElements());//20 总条数
        System.out.println(page.getTotalPages());// 7 总页数
        System.out.println(page.getContent());// 数据源
        System.out.println(page.getNumber());// 2  当前页+1，第三页
        System.out.println(page.getPageable());//
        System.out.println(page.getSize());//每页显示几条3
    }

springboot融合jdbc

1.导入依赖

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-jdbc</artifactId>
  </dependency>

2.测试CRUD

@Autowired
    private JdbcTemplate jdbcTemplate;
    @Test
    void jdbcpageUser() {
        //添加
        String sql="insert into tb_users values(?,?,?,?,?,?)";
        int update = jdbcTemplate.update(sql, "6868", "2", "2", "2", "2", "2");
        System.out.println(update);
    }
    @Test
    void jdbcfindpageUser() {
        //查询返回单个对象
        String sql="select * from tb_users where userid=?";
        Users users = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Users>(Users.class),"6868");
        System.out.println(users);
    }
    @Test
    void jdbcfindlistUser() {
        //查询返回一个集合
        String sql="select * from tb_users";
        List<Users> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Users>(Users.class));
        System.out.println(users);
    }
杨忠荣
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot 整合 Mybatis、JPA、Redis
程序员爱酸奶
09-22 1万+
引言 在springboot 项目中，我们是用ORM 框架来操作数据库变的非常方便。下面我们分别整合mysql ,spring data jpa 以及redis 。让我们感受下快车道。 我们首先创建一个springboot 项目，创建好之后，我们来一步步的实践。 使用mybatis 引入依赖： <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis
Tk_Batis 介绍和用法以及和Jpa 的区别
平凡的人类的博客
05-06 1948
什么是 Tk_Batis ？？（以下介绍仅代表个人看法） Tk_Batis 是在 MyBatis 框架的基础上提供了很多工具，个人感觉就相当于一个通用的 Mapper 仅限单一实体类操作 为什么要用 Tk ？？ 说实话，刚开始用 Tk 的时候我也吐槽过。。为啥要用 Tk 然后怎么怎么麻烦怎么怎么样的。。但是后来我发现，这个真的很提升效率问题，首先，如果你每个实体类都写一遍...
SpringBoot+Redis+JPA整合使用
adelyspace的专栏
04-02 485
SpringBoot_Redis_JPA整合使用 SpringBoot是这几年特别火的一个WEB应用程序开发框架，就我个人的理解的话其实SpringBoot没什么特别的内容可讲，因为内部还是Spring+SpringMVC那套东西，只不过把之前繁琐的配置现在都给重新又封装了一次，然后以约定大于配置指导思想为纲要，将大部分的配置直接省略了；再就是内置了Tomcat，这点就比...
SpringBoot整合SpringData JPA与Redis缓存
qq_39199351的博客
07-11 1360
1、使用idea 工具新建一个springboot工程 2、选中Web模块和SQL模块需要使用的启动器 3、新建好的项目选中idea的自动导包功能，idea将会自动为我们下载所依赖的maven包 4、使用docker启动一下mysql与redis容器 5、配置springboot的属性文件application.yml（配置application.properties效果一样） sprin...
SpringBoot系列教材 （二十四）- 其他 - springboot jpa redis 整合在一起做一套带分页的 增删改查 crud
Lan_ht的博客
07-29 111
如果用这种方式，就会导致数据不同步，即，虽然增加了，并且也增加到缓存中了，但是因为 key 不一样，通过查询拿到的数据，这样会到在，在增加数据之后，就会在Redis 中以 key= "category 71" 缓存一条数据。这个道理和 add 是一样的，仅仅删除 key= "category 71" ，没有什么意义， key: "category 0-5" 里面的数据没有影响呀。所以没有撸前面的同学，请先撸了，不然这里也撸不出来，因为数据库怎么建立都是在前面写的，你没做，后面也没法做的。
springboot整合redis、mybatis以及redis和mybatis的联合使用
09-17
springboot集成redis、mybatis 1、集成redis 2、集成mybatis 3、自定义redis KEY生成器/CacheManager来管理redis缓存 4、分布式redis-session共享 5、springboot实现初始化加载配置（实现缓存预热）的两种方式 6、二...
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
SpringBoot整合Redis源码 mybatis实战源码 封装RedisUtils工具类源码 redis缓存mybatis数据源码
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
springBoot集成redis
03-03
springBoot+mybatis+redis集成，不上代码要确保redis服务端已经运行
springboot2.X+mybatis+redis
03-23
springboot2.X+mybatis+redis 简单项目搭建以及使用，可以在实践中了解这三者的关系
mybatis 通用mapper
11-25
mybatis 通用mapper
TkMybatis运用到项目中，你看过吗？
qq_26795797的博客
06-04 343
什么是tkmybatis? 答：tkmybatis是中国的一些开发人员开发的一个持久层框架，这个框架对mybatis进行了一层封装，使用tkmybatis作为 持久层，操作起来，更为简洁 tkmybatis： 特点：它是基于jpa(Java 持久化规范)的一种技术,它可以在对象与数据表之间形成关联，操作对象就是操作数据表 使用tkmybatis:可以对单表或多表快速操作，如果对单独操作，不需要编写sql语句 SpringBoot中运用TkMybatis步骤 1、创建一个springboot项目 2、导入基本
springboot集成通用mapper（tk mybatis）
谁的博客
11-15 1483
项目结构 base：基础结构 modules：测试代码 集成 1. pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-ins...
JPA与TkMybatis事物机制
青色橙子
02-10 1572
引文 上一篇文章我们讲述了DDD+CQRS如何实现优雅查询(见：DDD+CQRS架构如何优雅实现查询)，大家肯定会有很多疑问，比如Spring是如何保证JPA与TkMybatis之间的事务一致性的问题。这篇文章我来带领大家走进Spring JPA的事务原理。 Spring JPA事务原理 在讲Spring JPA的事务原理之前我们先来讲一下Spring的事务原理。Spring的整个事务原理其实非常...
jpa 和 mybatis
weixin_57393819的博客
06-30 1万+
4. 用JPA书写repository层 二、mybatis 1. 简单介绍 MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。 MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。 MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Ordinary Java Objects，普通的 Java对象）映射成数据库中的记录。 2. mybatis的优势 简单易学：本身就很小且简单。没有任何第三方
tk-mybatis使用介绍，springboot整合tk-mybatis、PageHelper实现分页查询
最新发布
沐雨橙风ιε的博客
08-15 2425
目录第一步：准备数据库第二步：创建一个springboot项目 第三步：添加tk-mybatis的依赖第四步：修改配置文件第五步：创建数据库表对应的实体类第六步：持久层接口继承自Mapper接口第七步：使用tk-mybatis的API完成crud扩展：使用tk-mybatis整合PageHelper实现分页查询1、添加PageHelper依赖2、设置分页拦截器3、在所有代码之前开启分页创建数据库tkmybatis，然后执行以下脚本，为了方便起见，使用之前文章用的数据，也是我的歌单。 本篇文章将创建一个名
TkMybatis的使用
zhiwenganyong的博客
03-12 1116
TKMybatis 是基于 Mybatis 框架开发的一个工具，内部实现了对单表的基本数据操作，只需要简单继承 TKMybatis 提供的接口，就能够实现无需编写任何 sql 即能完成单表操作。
Springboot集成tkMybatis源码分析
qq_31086797的博客
03-04 485
前言 本文不介绍springboot如何集成tkMybatis,只介绍下集成的原理 什么是tkMybatis tkMybatis是对Mybatis的一个封装的框架，有点类似于hibernate的jpa，其作用是可以简化场景增删改查的sql语句，以及可以支持不使用mapper.xml配置文件，并且在接口上也可以支持编写sql语句 源码 我们直接从入口开始，tkMybatis的扫描注解MapperScan，该注解使用时需要配置扫描的路径，参数为value @Retention(RetentionPolicy.R
Springboot集成Redis
热门推荐
m0_59961940的博客
09-23 1万+
springboot集成redis
springboot+redis+mybatis
06-06
b'springboot+redis+mybatis' 是一个常用的后端开发架构。其中，springboot 是一个优秀的开发框架，能够快速搭建一个基于 Java 的 web 应用。Redis 是一个高性能的 NoSQL 数据库，主要用于缓存和存储数据。MyBatis 是一个优秀的 ORM 框架，主要用于操作数据库。这三个技术的结合，能够让开发者快速开发出高性能并且易于维护的后端服务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值