SpringCloud~实验出真理,搭建微服务架构环境,使用RestFul实现垮微服务交流

• 将一个项目的pojo对象,service服务,和controller服务,我将分为三个微服务

pojo服务

• 创建普通maven项目
• 创建数据库
  
• 实现pojo对象

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {

    private int id;
    private String name;
    private String pwd;
}

service服务

• 创建springBoot项目
• 导入依赖注意要将pojo服务的依赖与导入进来

  <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>

        <!-- 我们需要拿到实体类，所以要配置 pojo module-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>20201121_pojo</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

• 创建dao层接口

@Mapper
@Repository
public interface UserDao {

    List<User> selectAll();
    User query(@Param("id") int id);
    boolean add(User user);
    boolean delete(@Param("id") int id);
}

• 创建dao层对应的mapper文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.springcloud.dao.UserDao">

    <select id="selectAll" resultType="user">
        select * from user;
    </select>

    <select id="query" parameterType="_int" resultType="user">
        select * from user where id=#{id};
    </select>

    <insert id="add" parameterType="user">
        insert into user(name, pwd) values (#{name}, #{pwd});
    </insert>

    <delete id="delete" parameterType="_int">
        delete from user where id=#{id};
    </delete>

</mapper>

• 配置application.yml

server:
  port: 8080

mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.springcloud.pojo

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/java_11_21?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    username: root
    password: listen

• 创建实现service

public interface UserService {

    List<User> selectAll();
    User query(int id);
    boolean add(User user);
    boolean delete(int id);
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public List<User> selectAll() {
        return userDao.selectAll();
    }

    @Override
    public User query(int id) {
        return userDao.query(id);
    }

    @Override
    public boolean add(User user) {
        return userDao.add(user);
    }

    @Override
    public boolean delete(int id) {
        return userDao.delete(id);
    }
}

• 创建访问路径controller

@RestController
public class UserController {

    @Autowired
    private UserServiceImpl service;

    @RequestMapping("/select")
    public List<User> select() {
        return service.selectAll();
    }

    @RequestMapping("/query/{id}")
    public User query(@PathVariable("id")int id) {
        return service.query(id);
    }

    @RequestMapping("/add")
    public boolean add(User user) {
        System.out.println("[DEBUG]" + user);
        return service.add(user);
    }

    @RequestMapping("/delete/{id}")
    public boolean delete(@PathVariable("id")int id) {
        return service.delete(id);
    }

}

真正的controller服务

• 创建springBoot项目
• 导入依赖, 注意还要导入pojo服务的依赖

       <!-- 我们需要拿到实体类，所以要配置 pojo module-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>20201121_pojo</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

• 最好把tomcat启动端口设置为80 方便测试

server:
  port: 80

• 将RestTemplate注册到IOC中

@Configuration
public class ConfigBean {

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

• 实现controller

@RestController
public class UserController {

    @Autowired
    private RestTemplate template;

    final String PATH = "http://localhost:8080/";

    @RequestMapping("/all")
    public List<User> all() {
        String path = PATH + "select";
        System.out.println("[DEBUG]" + path);
        return template.getForObject(path, List.class);
    }

    @RequestMapping("/one/{id}")
    public User one(@PathVariable("id")int id) {
        String path = PATH + "query/" + id;
        System.out.println("[DEBUG]" + path);
        return template.getForObject(path, User.class);
    }

    @RequestMapping("/insert")
    public boolean add() {
        String path = PATH + "add" + "?id=0&name=duck&pwd=555555";
        System.out.println("[DEBUG]" + path);
        return template.getForObject(path, boolean.class);
    }
}

测试

• 我们访问controller这个微服务, 看是可以通过RestFul风格实现微服务之前的交流
• 启动service这个微服务, 再去启动controller这个微服务
  
• 通过上图的url可以发现,我们访问的是controller这个微服务, 但是他会进去service这个微服务中的数据,得到的pojo这个微服务产生的对象