SpringCloudNetFlix(微服务构建)学习

SpringCloudNetFlix(微服务构建)学习

SpringCloud入门概述

新建maven项目

编写spring-cloud-demo的pom.xml(导入依赖,这是父工程)

如果导入依赖下载完成后,依赖还是爆红,先把(<dependencyManagement></dependencyManagement>)这对标签删掉,知道依赖不爆红之后,再加上

<?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>top.tk.springcloud</groupId>
    <artifactId>spring-cloud-demo</artifactId>
    <version>1.0</version>

    <!--打包方式-->
    <packaging>pom</packaging>

    <properties>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- spring-cloud-dependencies -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- spring-boot-dependencies -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.1.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- mysql-connector-java -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            <!-- druid -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.6</version>
            </dependency>
            <!-- mybatis-spring-boot-starter -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.3.0</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>

创建spring-cloud-api公共模块

编写spring-cloud-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>spring-cloud-demo</artifactId>
        <groupId>top.tk.springcloud</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <!--当前Module的名字-->
    <artifactId>spring-cloud-api</artifactId>

    <!--当前Module自己需要的依赖,如果父依赖中配置了版本,这里就可以不用-->
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

现在我们创建一个数据库(springcloud-db),创建用户数据库脚本

CREATE TABLE `user`  (
  `uid` int(11) NOT NULL,
  `uname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `uage` int(11) DEFAULT NULL,
  `db_source` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  PRIMARY KEY (`uid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

INSERT INTO `user` VALUES (1, '小明', 25, 'db_01');
INSERT INTO `user` VALUES (2, '小黑', 18, 'db_01');
INSERT INTO `user` VALUES (3, '小红', 33, 'db_01');
INSERT INTO `user` VALUES (4, '小金', 20, 'db_01');
INSERT INTO `user` VALUES (5, '小美', 19, 'db_01');

SET FOREIGN_KEY_CHECKS = 1;

编写实体类, 实体类都需要序列化！！！

package top.tk.springcloud.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;

/**
 * @ClassName: User
 * @Author: campsis-tk
 * @Date: 2020/8/25 11:17
 * @Description:
 **/
@Data
@NoArgsConstructor
@Accessors(chain = true)    //链式写法 dept.setUId(1).setUName('okOk').setDbSource('db_01');
public class User implements Serializable {
	private Long uid;
	private String uname;
	private Integer uage;
	private String dbSource;

	public User(Integer uage, String dbSource) {
		this.uage = uage;
		this.dbSource = dbSource;
	}
}

按照上面的创建方式,创建spring-cloud-provider-6001模块,导入依赖

<?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>spring-cloud-demo</artifactId>
        <groupId>top.tk.springcloud</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-cloud-provider-6001</artifactId>

    <dependencies>
        <!--引入自定义的模块，我们就可以使用这个模块中的类了-->
        <dependency>
            <groupId>top.tk.springcloud</groupId>
            <artifactId>spring-cloud-api</artifactId>
            <version>1.0</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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <!-- spring-boot-devtools -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>
</project>

在spring-cloud-provider-6001中创建application.yml

编写yml文件

#端口
server:
  port: 6001

#mybatis配置
mybatis:
  type-aliases-package: top.tk.tk.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
  config-location: classpath:mybatis/mybatis-config.xml

#Spring配置
spring:
  application:
    name: springcloud-provider-user
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource #数据源
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
    username: root
    password: root

根据配置新建mybatis-config.xml文件

编写mybatis-config.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>
    <settings>
        <!--开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>

编写用户的UserMapper接口

package top.tk.springcloud.mapper;


import org.apache.ibatis.annotations.Mapper;
import top.tk.springcloud.pojo.User;

import java.util.List;

/**
  * @ClassName: UserMapper
  * @Author: campsis-tk
  * @Date: 2020/8/25 11:51
  * @Description: mapper接口
  **/
@Mapper
public interface UserMapper {

    List<User> queryAllUser();

    int deleteByPrimaryKey(Integer uid);

    int insert(User record);

    int insertSelective(User record);

    User selectByPrimaryKey(Integer uid);

    int updateByPrimaryKeySelective(User record);

    int updateByPrimaryKey(User record);
}

Mapper接口对应的Mapper.xml文件 mybatismapperDeptMapper.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="top.tk.springcloud.mapper.UserMapper">
    <resultMap id="BaseResultMap" type="top.tk.springcloud.pojo.User">
        <!--@mbg.generated-->
        <!--@Table `user`-->
        <id column="uid" jdbcType="INTEGER" property="uid"/>
        <result column="uname" jdbcType="VARCHAR" property="uname"/>
        <result column="uage" jdbcType="INTEGER" property="uage"/>
        <result column="db_source" jdbcType="VARCHAR" property="dbSource"/>
    </resultMap>
    <sql id="Base_Column_List">
        <!--@mbg.generated-->
        `uid`, uname, uage, db_source
    </sql>
    <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
        <!--@mbg.generated-->
        select
        <include refid="Base_Column_List"/>
        from `user`
        where `uid` = #{uid,jdbcType=INTEGER}
    </select>
    <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
        <!--@mbg.generated-->
        delete from `user`
        where `uid` = #{uid,jdbcType=INTEGER}
    </delete>
    <insert id="insert" parameterType="top.tk.springcloud.pojo.User">
        <!--@mbg.generated-->
        insert into `user` (`uid`, uname, uage,
        db_source)
        values (#{uid,jdbcType=INTEGER}, #{uname,jdbcType=VARCHAR}, #{uage,jdbcType=INTEGER},
        #{dbSource,jdbcType=VARCHAR})
    </insert>
    <insert id="insertSelective" parameterType="top.tk.springcloud.pojo.User">
        <!--@mbg.generated-->
        insert into `user`
        <trim prefix="(" suffix=")" suffixOverrides=",">
            <if test="uid != null">
                `uid`,
            </if>
            <if test="uname != null">
                uname,
            </if>
            <if test="uage != null">
                uage,
            </if>
            <if test="dbSource != null">
                db_source,
            </if>
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
            <if test="uid != null">
                #{uid,jdbcType=INTEGER},
            </if>
            <if test="uname != null">
                #{uname,jdbcType=VARCHAR},
            </if>
            <if test="uage != null">
                #{uage,jdbcType=INTEGER},
            </if>
            <if test="dbSource != null">
                #{dbSource,jdbcType=VARCHAR},
            </if>
        </trim>
    </insert>
    <update id="updateByPrimaryKeySelective" parameterType="top.tk.springcloud.pojo.User">
        <!--@mbg.generated-->
        update `user`
        <set>
            <if test="uname != null">
                uname = #{uname,jdbcType=VARCHAR},
            </if>
            <if test="uage != null">
                uage = #{uage,jdbcType=INTEGER},
            </if>
            <if test="dbSource != null">
                db_source = #{dbSource,jdbcType=VARCHAR},
            </if>
        </set>
        where `uid` = #{uid,jdbcType=INTEGER}
    </update>
    <update id="updateByPrimaryKey" parameterType="top.tk.springcloud.pojo.User">
        <!--@mbg.generated-->
        update `user`
        set uname = #{uname,jdbcType=VARCHAR},
        uage = #{uage,jdbcType=INTEGER},
        db_source = #{dbSource,jdbcType=VARCHAR}
        where `uid` = #{uid,jdbcType=INTEGER}
    </update>
    <select id="queryAllUser" resultMap="BaseResultMap">
        select * from `user`
    </select>
</mapper>

创建UserService服务层接口

package top.tk.springcloud.service;

import top.tk.springcloud.pojo.User;

import java.util.List;

/**
  * @ClassName: UserService
  * @Author: campsis-tk
  * @Date: 2020/8/25 11:51
  * @Description: UserService接口
  **/
public interface UserService{

    //查询所有用户
    List<User> queryAllUser();

    //根据主键删除
    int deleteByPrimaryKey(Integer uid);

    //添加
    int insert(User record);

    //添加(选择性添加)
    int insertSelective(User record);

    //按照主键查询信息
    User selectByPrimaryKey(Integer uid);

    //按照主键修改(选择性修改)
    int updateByPrimaryKeySelective(User record);

    //按照主键修改
    int updateByPrimaryKey(User record);

}

创建UserService服务层接口实现类

package top.tk.springcloud.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import top.tk.springcloud.mapper.UserMapper;
import top.tk.springcloud.pojo.User;
import top.tk.springcloud.service.UserService;

import java.util.List;

/**
  * @ClassName: UserServiceImpl
  * @Author: campsis-tk
  * @Date: 2020/8/25 11:51
  * @Description: UserService实现类
  **/
@Service
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userMapper;

    @Override
    public List<User> queryAllUser() {
        return userMapper.queryAllUser();
    }

    @Override
    public int deleteByPrimaryKey(Integer uid) {
        return userMapper.deleteByPrimaryKey(uid);
    }

    @Override
    public int insert(User record) {
        return userMapper.insert(record);
    }

    @Override
    public int insertSelective(User record) {
        return userMapper.insertSelective(record);
    }

    @Override
    public User selectByPrimaryKey(Integer uid) {
        return userMapper.selectByPrimaryKey(uid);
    }

    @Override
    public int updateByPrimaryKeySelective(User record) {
        return userMapper.updateByPrimaryKeySelective(record);
    }

    @Override
    public int updateByPrimaryKey(User record) {
        return userMapper.updateByPrimaryKey(record);
    }
}

编写UserController

package top.tk.springcloud.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import top.tk.springcloud.pojo.User;
import top.tk.springcloud.service.UserService;

import java.util.List;

/**
 * @ClassName: UserController
 * @Author: campsis-tk
 * @Date: 2020/8/25 14:04
 * @Description: user控制器
 **/
@RestController
@RequestMapping("/user")    //根路径
public class UserController {

	@Autowired
	private UserService userService;

	@GetMapping("/get/{id}")
	public User get(@PathVariable("id") Integer id){
		return userService.selectByPrimaryKey(id);
	}

	@GetMapping("/list")
	public List<User> queryAllUser() {
		return userService.queryAllUser();
	}
}

编写UserProviderApplication_6001启动类

package top.tk.springcloud;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.Environment;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @ClassName: UserProviderApplication_6001
 * @Author: campsis-tk
 * @Date: 2020/8/25 14:07
 * @Description: 启动类
 **/
@Slf4j
@SpringBootApplication
public class UserProviderApplication_6001 {
	public static void main(String[] args) throws UnknownHostException {
		ConfigurableApplicationContext application = SpringApplication.run(UserProviderApplication_6001.class, args);
		//打印信息
		Environment env = application.getEnvironment();
		String ip = InetAddress.getLocalHost().getHostAddress();
		String port = env.getProperty("server.port");
		String path = env.getProperty("server.servlet.context-path");
		String hj = env.getProperty("spring.profiles.active");
		log.info("
----------------------------------------------------------
	" +
				"Application Tk Cloud is running! Access URLs:
	" +
				"IP: 		" + ip + "
	" +
				"Port: 		" + port + "
	" +
				"Local: 		http://localhost:" + port + "/
	" +
				"当前配置环境: 		当前环境为:" + hj + "
" +
				"----------------------------------------------------------");
	}
}

spring-cloud-provider-6001模块结构

最后打开浏览器访问http://localhost:6001/user/get/1

创建consumer模块

新建spring-cloud-consumer-user-80模块,导入依赖

<?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>spring-cloud-demo</artifactId>
        <groupId>top.tk.springcloud</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-cloud-consumer-user-80</artifactId>
    <description>用户微服务消费者</description>

    <dependencies>
        <dependency>
            <groupId>top.tk.springcloud</groupId>
            <artifactId>spring-cloud-api</artifactId>
            <version>1.0</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>

编辑spring-cloud-consumer-user-80 application.yml 配置文件

server:
	port: 80

新建Config包在下面新建一个ConfigBean包注入 RestTemplate

package top.tk.springcloud.config;

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

/**
 * @ClassName: ConfigBean
 * @Author: campsis-tk
 * @Date: 2020/8/26 14:25
 * @Description:
 **/
@Configuration
public class ConfigBean {

	@Bean
	public RestTemplate getRestTemplate(){
		return new RestTemplate();
	}
}

创建Controller包，编写UserConsumerController类

package top.tk.springcloud.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import top.tk.springcloud.pojo.User;

import java.util.List;

/**
 * @ClassName: UserConsumerController
 * @Author: campsis-tk
 * @Date: 2020/8/26 14:26
 * @Description:
 **/
@RestController
@RequestMapping("/consumer")
public class UserConsumerController {
	//理解：消费者，不应该有service层
	//使用RestTemplate访问restful接口非常的简单粗暴且无脑
	//（url，requestMap，ResponseBean.class） 这三个参数分别代表
	//REST请求地址，请求参数，Http响应转换 被 转换成的对象类型

	@Autowired
	private RestTemplate restTemplate;

	private static final String REST_URL_PREFIX = "http://localhost:6001";

	@RequestMapping("/user/get/{id}")
	public User get(@PathVariable("id") Long id){
		return restTemplate.getForObject(REST_URL_PREFIX+"/user/get/" + id,User.class);
	}
	@RequestMapping("/user/list")
	public List<User> list(){
		return restTemplate.getForObject(REST_URL_PREFIX+"/user/list",List.class);
	}
}

创建UserConsumerApplication_80主启动类

package top.tk.springcloud;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.Environment;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @ClassName: UserConsumerApplication_80
 * @Author: campsis-tk
 * @Date: 2020/8/26 14:34
 * @Description:
 **/
@Slf4j
@SpringBootApplication
public class UserConsumerApplication_80 {
	public static void main(String[] args) throws UnknownHostException {
		ConfigurableApplicationContext application = SpringApplication.run(UserConsumerApplication_80.class, args);
		//打印信息
		Environment env = application.getEnvironment();
		String ip = InetAddress.getLocalHost().getHostAddress();
		String port = env.getProperty("server.port");               //端口
		String path = env.getProperty("server.servlet.context-path");//根路径
		String hj = env.getProperty("spring.profiles.active");       //环境
		log.info("
----------------------------------------------------------
	" +
				"Application Tk Cloud is running! Access URLs:
	" +
				"IP: 		" + ip + "
	" +
				"Port: 		" + port + "
	" +
				"Local: 		http://localhost:" + port + "/
	" +
				"当前配置环境: 		当前环境为:" + hj + "
" +
				"----------------------------------------------------------");
	}
}

先启动spring-cloud-provider-6001,在启动spring-cloud-consumer-user-80,访问测试http://localhost/consumer/user/get/1

了解RestTemplate：

RestTemplate提供了多种便捷访问远程Http服务的方法，是一种简单便捷的访问restful服务模板 类，是Spring提供的用于访问Rest服务的客户端模板工具集

使用RestTemplate访问restful接口非常的简单粗暴且无脑 （url，requsetMap，ResponseBean.class） 这三个参数分别代表REST请求地址，请求参数， Http响应转换 被 转换成的对象类型

敬请期待明天的Eureka服务注册与发现

案例

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Campsis-tk/p/13558330.html