微服务架构之SpringCloud学习笔记(二)

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量250 收藏
点赞数 1
分类专栏： 微服务架构与分布式 文章标签： java spring 分布式 后端 mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MarkZQP/article/details/106447487
版权

项目总体介绍

  • 使用一个Dept部门模块做一个微服务通用案例Consumer消费者（Client）通过REST调用REST调用Provider提供者（Server）提供服务
  • 一个简单的Maven的模块结构是这样的
    在这里插入图片描述
  • 一个父工程带着多个Moudule子模块
    MicroServiceCloud父工程（Project）下先有三个子模块（Module）
    • microservicecloud-api (改模块封装了实体集entity/接口/公共配置等）
    • microservicecloud-provider-dept-8001（服务提供者）
    • microservicecloud-consumer-dept-80 （服务消费者）

创建一个父工程

  1. 因为父工程需要管理其他子模块的一些依赖文件，所以选择创建一个空的maven项目，这样的话，就有pom.xml来管理相关依赖。
    其中父工程的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-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kuang</groupId>
    <artifactId>springcloud</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springcloud-api</module>
        <module>springcloud-provide-dept-8001</module>
        <module>springcloud-consumer-dept-80</module>
    </modules>
    <packaging>pom</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <log4j.version>1.2.17</log4j.version>
        <junit.version>4.12</junit.version>
        <lombok.version>1.16.18</lombok.version>
    </properties>
    <dependencyManagement>  <!--注意dependencyManagement与普通的Dependencies的区别 -->
        <dependencies>
            <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--springboot-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.1.4.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--数据库-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.46</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.10</version>
            </dependency>
            <!--springboot启动器-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.3.2</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.3</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

注意： 这里我们可以看到使用了<dependencyManagement> 这个标签，我们可以学习一下<dependencyManagement> 与<dependencies> 的使用区别！

区别：
dependencies即使在子项目中不写该依赖项，那么子项目仍然会从父项目中继承该依赖项（全部继承）。
dependencyManagement 里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

好处: 统一管理项目的版本号，确保应用的各个项目的依赖和版本一致，才能保证测试的和发布的是相同的成果，因此，在顶层pom中定义共同的依赖关系。同时可以避免在每个使用的子项目中都声明一个版本号，这样想升级或者切换到另一个版本时，只需要在父类容器里更新，不需要任何一个子项目的修改；如果某个子项目需要另外一个版本号时，只需要在dependencies中声明一个版本号即可。子类就会使用子类声明的版本号，不继承于父类版本号。

在这里父项目的任务已经完成了，下面可以分别创建它的3个子模块了

模块1：springcloud-api （pojo实体集）

注：springcloud-api 模块名

子模块的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-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.kuang</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-api</artifactId>
    <!--当前的Module自己需要的依赖，如果父依赖中已经配置了依赖版本，那么在这里就不用写了-->
    <dependencies>
     <!--这个模块的依赖仅仅用来生成get，set方法和构造函数-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

pojo实体类

package com.kuang.springcloud.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;
@NoArgsConstructor
@Data
@Accessors(chain = true)    //链式写法
public class Dept implements Serializable {
    private long deptNo;
    private String deptName;
    //同一个信息被存在于不同的数据库，这就是这个字段存在的原因
    private String dbSource;
    public Dept(String deptName){
        this.deptName=deptName;
    }
    /*
      链式写法
      比如
      Dept dept=new Dept();
      dept.setDeptNo(111).setDeptName("zengqingping")
      这个就是链式写法
     */
}

到这里，模块1就已经完成了，它只是一个pojo实体类供后面的模块使用

模块2：springcloud-provide-dept-8001(服务提供者）

注：springcloud-provide-dept-8001是子模块名

  • 子模块项目结构图为：
    在这里插入图片描述

子模块的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-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.kuang</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-provide-dept-8001</artifactId>
    <dependencies>
        <!--我们需要拿到实体类，所有我们在依赖这里配置api module-->
        <dependency>
            <groupId>com.kuang</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!--test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jetty   一个类似于tomcat的web应用服务器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <!--热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>
</project>

注：由于在父工程里的dependencyManagement管理了相关依赖的版本，所以这里不需要再配置版本信息，如果需要覆盖父工程的部分模块的版本可以在这里进行配置。

子模块application.yml配置文件

注 ：需要创建一个springcloud数据库，然后在该数据库下创建一个dept的表，其中列名分别为deptNo,deptName,dbSource

server:
  port: 8001
mybatis:
  type-aliases-package: com.kuang.springcloud.pojo
  mapper-locations: classpath:/mapper/*.xml
  config-location: classpath:mybatis-config.xml
#  configuration:
#    map-underscore-to-camel-case: true    //驼峰命名的与数据库中下划线的转换
spring:
  application:
    name: springcloud-provide-dept-8001
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource #数据源
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springcloud?useUnicode=true&characterEncoding=utf-8
    username: root
    password: root

dao层

package com.kuang.springcloud.dao;

import com.kuang.springcloud.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;
@Mapper
@Repository
public interface DeptDao {
    public boolean addDept(Dept dept);
    public Dept queryById(Long id);
    public List<Dept> queryAll();
}

Service层代码

package com.kuang.springcloud.service;

import com.kuang.springcloud.pojo.Dept;
import java.util.List;
public interface DeptService {
    public boolean addDept(Dept dept);
    public Dept queryById(Long id);
    public List<Dept> queryAll();
}

接口实现类：

package com.kuang.springcloud.service;

import com.kuang.springcloud.dao.DeptDao;
import com.kuang.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class DeptServiceImp implements DeptService {
    @Autowired
    DeptDao deptDao;
    @Override
    public boolean addDept(Dept dept) {
        return deptDao.addDept(dept);
    }

    @Override
    public Dept queryById(Long id) {
        return deptDao.queryById(id);
    }

    @Override
    public List<Dept> queryAll() {
        return deptDao.queryAll();
    }

}

Controller层

package com.kuang.springcloud.controller;

import com.kuang.springcloud.pojo.Dept;
import com.kuang.springcloud.service.DeptService;
import com.kuang.springcloud.service.DeptServiceImp;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

//提供Restful服务的
@RestController
@RequestMapping("/dept")
public class DeptController {

    @Autowired
    private DeptService deptService;

    @PostMapping("/add")
    public boolean addDept(Dept dept){
        return deptService.addDept(dept);
    }
    @GetMapping("/get/{id}")
    public Dept getDept(@PathVariable("id") Long id){
        return deptService.queryById(id);
    }

    @GetMapping("/list")
    public List<Dept> getAll(){
        return deptService.queryAll();
    }
}

Mybatis对应得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.kuang.springcloud.dao.DeptDao">-->
<mapper namespace="com.kuang.springcloud.dao.DeptDao">
    <resultMap id="Dept" type="com.kuang.springcloud.pojo.Dept">
        <result property="deptNo" column="deptNo"></result>
        <result property="deptName" column="deptName"></result>
        <result property="dbSource" column="dbSource"></result>
    </resultMap>

    <insert id="addDept" parameterType="Dept">
        insert into dept(deptName,dbSource)
        values (#{deptName},DATABASE())
    </insert>

    <select id="queryById" resultMap="Dept" parameterType="Long">
        SELECT *
        FROM dept
        where deptNo=#{deptNo}
    </select>
    <select id="queryAll" resultMap="Dept" >
        select *
        from dept
    </select>
</mapper>

mybatis的配置文件

<?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>

    <settings>
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>

自己手动添加sprinboot启动类

package com.kuang.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}

问答：我们可以看到这个服务提供者模块的DAO层直接可以调用POJO实体类，但是该模块并没有POJO实体类，这是因为在上一个模块已经单独把POJO实体类给提取出来了，这里通过了pom坐标直接引入了。
那么这一块又有什么作用呢？
答: 在我们的思维中可以知道一个消费层，并不需要dao层，service层。就像我们访问百度一样，直接输入相应的请求即可。所以这个服务提供层面的作用是：将自己的RESTFUL接口暴露出来供消费模块使用

模块3：springcloud-consumer-dept-80(服务消费者)

注：springcloud-consumer-dept-80是子模块名

  • 子模块项目结构图为：
    在这里插入图片描述

子模块的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-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.kuang</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-consumer-dept-80</artifactId>
    <dependencies>
        <!--实体类+web-->
        <dependency>
            <groupId>com.kuang</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>
</project>

子模块application.yml配置文件

server:
  port: 80

controller层

package com.kuang.springcloud.controller;

import com.kuang.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;
@RestController
public class DeptConsumerController {
    //理解 消费者，不应该有service层
    //RestFul
    //RestTemplate
    @Autowired
    private RestTemplate restTemplate;        //提供多种便捷访问远程http服务的方法，简单的Restful服务模板。

    private static final String REST_URL="http://localhost:8001";

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        Dept dept = restTemplate.getForObject(REST_URL + "/dept/get/" + id, Dept.class);
        return dept;
    }
    @RequestMapping("/consumer/dept/add")
    public boolean addDept(@RequestBody Dept dept){

        return restTemplate.postForObject(REST_URL+"/dept/add",dept,Boolean.class);
    }
    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){

        return restTemplate.getForObject(REST_URL + "/dept/list" , List.class);
    }
}

由于用到了RestTemplate这个Bean并没有注册到spring容器中，所以需要手动进行配置

手动配置一个bean

package com.kuang.springcloud.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {   //@Configuration 相当于--spring applicationContext.xml 然后只需要在里面配置bean就行了
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

自己手动添加springboot启动类

package com.kuang.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

项目测试

模块2：服务提供者模块测试

问题： 只要完成了消费者接口就可以了，为什么不直接测试 消费者模块？
答 ：因为我们首先要确保服务提供者所暴露出来的接口时没有问题的，直接测消费者接口如果报错，不容易找到错误的原因。

  • 使用postman进行测试，因为如果仅使用浏览器的话不能够发出post请求。

    • 测试添加部门：在这里插入图片描述
      问题： 为什么提交的“表单数据”就只有一个deptName,而没有·deptNo和dbSource？
      答： 创建数据表时，默认deptNo是自增的，同时，在DeptMapperxml的SQL语句中可以知道，插入的dbSource在SQL语句中已经写死了，所以不需要在表单中加上。
    • 测试查询部门
      在这里插入图片描述

模块3：服务消费者模块测试

  • 测试添加模块
    在这里插入图片描述

  • 测试查询模块
    在这里插入图片描述

注意事项

在测试之前先要用在springboot启动类下启动两个模块，然后再进行测试，测试的时候要注意端口号。

博客总结于：狂神说Java视频。B站地址：https://space.bilibili.com/95256449h

MarkZQP
关注
专栏目录
springcloud学习笔记.pdf
03-12
Spring Cloud 学习笔记 本笔记主要介绍了从单体架构到微服务架构的演变过程，以及 Spring Cloud 中的微服务架构搭建。下面是本笔记的详细知识点总结： 一、单体架构 单体架构是指整个系统只有一个工程，打包往往...
SpringCloud-1-概念及实现模块间调用
战无道的博客
11-07 1259
一、概念 1.1系统架构的演变 1.1.1 单体项目 Web应用程序发展的早期，大部分web工程(包含前端页面,web层代码,service层代码,dao层代码)是将所有的功能模块,打包到一起并放在一个web容器中运行。 优点： 所有的功能集成在一个项目工程中 项目架构简单，前期开发成本低，周期短，小型项目的首选。 缺点： 全部功能集成在一个工程中，对于大型项目不易开发、扩展及维护。 系统性能扩展只能通过扩展集群结点，成本高、有瓶颈。 技术栈受限。 1.1.2垂直拆分 当访问量逐渐增大，单一应用增加机器带
SpringCloud学习笔记（三）（狂神视频笔记）
hexinqiong的博客
05-02 213
SpringCloud（三） 4、Rest学习环境搭建：服务提供者 总体介绍 我们会使用一个Dept部门模块做一个微服务通用案例Consumer消费者（Client）通过REST调用Provider提供者（Server）提供的服务。 回忆Spring，SpringMVC，MyBatis等以往学习的知识。。。 Maven的分包分模块架构复习 一个简单的Maven模块结构是这样的： – app-parent：一个父项目（app-parent）聚合很多子项目（app-util，app-dao，a
springboot项目Invalid bound statement (not found): com.xxxx.dao.xxxDAO.xxx解决方法
热门推荐
zhang33565417的博客
07-20 2万+
一开始看到控制台报了这个错误 找了半天没找到什么错误，jar包也引了，@MapperScan注解也没错，mapper.xml文件路径也没错，最后才发现application.xml配置文件的MyBatis的配置的mapper-locations的路径写错了 这写成了.*xml 改成*.xml就好了，细心！细心！细心！ ...
java找不到返回值_java.lang.IllegalArgumentException:找不到类型返回值的转换器
weixin_28687685的博客
03-02 294
有了这段代码@RequestMapping(value = "/bar/foo", method = RequestMethod.GET)public ResponseEntity foo() {Foo model;...return ResponseEntity.ok(model);}}我得到以下异常java.lang.IllegalArgumentException: No converter...
黑马程序员-SpringCloud-学习笔记01-认识微服务
06-18
黑马程序员-SpringCloud-学习笔记01-认识微服务
SpringCloud微服务架构笔记-共四部分四个PDF文件
07-04
本套笔记全面覆盖了SpringCloud微服务架构的关键知识点，从理论到实践，帮助读者深入了解并掌握微服务设计原则和SpringCloud的实现方式，对于想要在微服务领域深化学习的Java开发者来说是一份宝贵的资料。
java找不到返回值_Spring Boot应用程序：找不到类型为返回值的转换器
weixin_34812649的博客
03-02 293
我REST API根据此 Spring-Boot教程编写了一个简单的文章。在我本地的开发机器(Ubuntu 15.04和Windows 8.1)上，所有内容都像一个魅力。我有一台旧32-bit Ubuntu 12.04 LTS服务器，我想在上面部署我的REST服务。起始日志可以，但是一旦我向端点发送GET请求/user/{id}，就会出现以下错误：java.lang.IllegalArgument...
Field productMapper in com.xxx.springcloud.service.ProductImpl required a bean of type
weixin_44127299的博客
09-10 1760
错误原图： 解决方案 将这段注解后面半段删除，即： 错误就解决了 可以正常运行
狂神说SpringCloud学习笔记
Filwaod
04-12 1731
1.微服务概述 1.什么是微服务架构？ 究竟什么是微服务架构呢？我们在此引用ThoughtWorks 公司的首席科学家 Martin Fowler 于2014年提出的一段话： 微服务架构是一种架构模式，或者说是一种架构风格，它将单一的应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终价值，服务之间采用轻量级的通信机制(HTTP)互相沟通，每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 137
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 814
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 874
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 252
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 412
函数式接口与回调函数
Java复习24（PTA)
2301_79272475的博客
10-30 409
Java复习24（PTA)：多种排序的book类*
微服务架构开发利器：SpringCloud学习笔记最新总结
SpringCloud学习笔记整理最新版本针对的是微服务架构下的开发实践，主要聚焦于Spring Cloud这一基于Spring Boot的分布式系统综合解决方案。以下内容将对Spring Cloud涉及的关键知识点进行详细梳理。 **基础概念和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值