2006-京淘Day11

1.关于tomcat服务器脚本

1.1 问题说明

如果通过命令: java -jar xxx.war 的方式启动服务器时,如果远程的终端关闭之后,那么tomcat服务器也会随之关闭.影响用户的使用. 上述的命令 表示前台运行.

1.2 线上部署的命令

说明: 一般在Linux系统中部署服务器 一般采用后端运行的方式 启动tomcat服务器.并且指定日志文件输出.
命令: nohup java -jar 8081.war -> 8081.log &

1.3 关于文件查看的说明

cat 输出文件所有的内容
more 输出文档所有的内容，分页输出，空格浏览下一屏，q退出
less 用法和more相同，只是通过PgUp、PgOn键来控制 q退出
tail 用于显示文件后几号，使用频繁
tail -10 nginx.conf 查看nginx.conf的最后10行
tail –f nginx.conf 动态查看日志，方便查看日志新增的信息
ctrl+c 结束查看

1.4 Linux 脚本说明

说明: Linux中的"脚本"(外挂-荒野行动)的后缀为.sh
创建文件: vim start.sh

执行脚本:

2 数据库代理说明

2.1 数据库结构的优化

说明:由于需要用户同时链接2台甚至多台数据库时需要引入代理,所以有如下的部署.
注意事项: 用户链接代理服务器 端口号一般:8066端口

2.2 Mycat介绍

2.3 Mycat部署

2.3.1 上传Mycat安装包

解压Mycat压缩包:

 tar -zxvf Mycat-server-1.7.0-DEV-20170416134921-linux.tar.gz
 

2.3.2 检查JDK是否安装

2.4 关于Mycat配置文件说明

2.4.1 server.xml配置文件说明

说明:在server.xml配置文件中定义用户名和密码及操作的数据库信息,必须与YML配置文件一致.

2).修改YML配置文件

2.4.2 schemas配置文件说明

说明:schemas文件主要的作用就是配置数据库读写的策略.

<writeHost host="hostM1" url="192.168.126.129:3306" user="root" password="root">
            <!--读数据库1-->
            <readHost host="hostS1" url="192.168.126.130:3306" user="root" password="root" />
            <!--读数据库2-->
            <readHost host="hostS2" url="192.168.126.129:3306" user="root" password="root" />
</writeHost>

2.5 Mycat测试

启动命令:

Mycat测试:

2.6 数据库实现高可用

高可用: 保证服务尽可能的不宕机,保证用户正常使用.

2.6.1 数据库双机热备

说明:一般在公司中配置双机热备的形式,配置为互为主从.

配置说明:
1.主库 192.168.126.130

2.从库 192.168.126.129

/*实现主从的挂载*/
CHANGE MASTER TO MASTER_HOST="192.168.126.130",
MASTER_PORT=3306,
MASTER_USER="root",
MASTER_PASSWORD="root",
MASTER_LOG_FILE="mysql-bin.000001",
MASTER_LOG_POS=482

/*启动主从服务*/
START SLAVE    

/*检查主从状态*/
SHOW SLAVE STATUS;

 

2.6.2 实现数据库高可用配置

说明:修改完成数据库之后,将配置文件上传即可.

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
    
    <!--name属性是自定义的  dataNode表示数据库的节点信息  jtdb表示逻辑库-->
    <schema name="jtdb" checkSQLschema="false" sqlMaxLimit="100" dataNode="jtdb"/>

    <!--定义节点名称/节点主机/数据名称-->
    <dataNode name="jtdb" dataHost="localhost1" database="jtdb" />
        <!--参数介绍 UTF-8 中文报错-->
        <!--balance 0表示所有的读操作都会发往writeHost主机 -->  
        <!--1表示所有的读操作发往readHost和闲置的主节点中-->
        <!--writeType=0 所有的写操作都发往第一个writeHost主机-->    
        <!--writeType=1 所有的写操作随机发往writeHost中-->
        <!--dbType 表示数据库类型 mysql/oracle-->
        <!--dbDriver="native"  固定参数 不变-->
        <!--switchType=-1 表示不自动切换, 主机宕机后不会自动切换从节点-->
        <!--switchType=1  表示会自动切换(默认值)如果第一个主节点宕机后,Mycat会进行3次心跳检测,如果3次都没有响应,则会自动切换到第二个主节点-->
        <!--并且会更新/conf/dnindex.properties文件的主节点信息 localhost1=0 表示第一个节点.该文件不要随意修改否则会出现大问题-->
    <dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"
              writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
        <heartbeat>select 1</heartbeat>

        <!--配置第一台主机主要进行写库操作,在默认的条件下Mycat主要操作第一台主机在第一台主机中已经实现了读写分离.因为默认写操作会发往137的数据库.读的操作默认发往141.如果从节点比较忙,则主节点分担部分压力.
        -->
        <writeHost host="hostM1" url="192.168.126.129:3306" user="root" password="root">
            <!--读数据库1-->
            <readHost host="hostS1" url="192.168.126.130:3306" user="root" password="root" />
            <!--读数据库2-->
            <readHost host="hostS2" url="192.168.126.129:3306" user="root" password="root" />
            
        </writeHost>

            <!--定义第二台主机 由于数据库内部已经实现了双机热备.-->
            <!--Mycat实现高可用.当第一个主机137宕机后.mycat会自动发出心跳检测.检测3次.-->
            <!--如果主机137没有给Mycat响应则判断主机死亡.则回启东第二台主机继续为用户提供服务.-->
            <!--如果137主机恢复之后则处于等待状态.如果141宕机则137再次持续为用户提供服务.-->
            <!--前提:实现双机热备.-->
        
        <writeHost host="hostM2" url="192.168.126.130:3306" user="root" password="root">
            
            <readHost host="hostS1" url="192.168.126.130:3306" user="root" password="root" />
            
            <readHost host="hostS2" url="192.168.126.129:3306" user="root" password="root" />
        </writeHost>
        
    </dataHost>
</mycat:schema>

2.6.2 实现数据库高可用测试

测试步骤:
1.关闭主数据库,之后检索数据,检查用户的访问是否受限.
2.修改数据库记录,检查用户的操作是否正常. (操作的是从库)
3.重启主数据库 之后检查从库的数据是否同步.

3. Redis学习

3.1还原程序

3.1.1 修改YML配置文件

 

3.1.2 修改pro图片路径

3.1.3 修改Nginx配置文件

3.1.4 修改hosts文件

3.2 缓存机制

说明:使用缓存可以有效的降低用户访问物理设备的频次.快速从内存中获取数据,之后返回给用户,同时需要保证内存中的数据就是数据库数据.
思考:
1.缓存的运行环境应该在内存中.(快)
2.使用C语言开发缓存
3.缓存应该使用什么样的数据结构呢--------K-V结构 一般采用String类型居多 key必须唯一 . v:JSON格式
4.内存环境断电即擦除,所以应该将内存数据持久化(执行写盘操作)
5.如果没有维护内存的大小,则容易导致 内存数据溢出. 采用LRU算法优化!!!

3.3 Redis介绍

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。

原子性说明: Redis的操作是单进程单线程操作,所以没有线程并发性的安全问题. 采用队列的方式一个一个操作.
Redis常见用法:
1.Redis可以当做缓存使用
2.Redis可以当做数据库使用 验证码
3.Redis可以消息中间件使用 银行转账等

3.4 Redis安装

1).解压 Redis安装包

[root@localhost src]# tar -zxvf redis-5.0.4.tar.gz
 

2). 安装Redis
说明:在Redis的根目录中执行命令
命令: 1.make
2.make install

3.5 修改Redis的配置文件

命令1: 展现行号 :set nu

修改位置1: 注释IP绑定

修改位置2: 关闭保护模式
 

修改位置3: 开启后台启动

3.6 redis 服务器命令

1.启动命令: redis-server redis.conf
2.检索命令: ps -ef | grep redis
3.进入客户端: redis-cli -p 6379
4.关闭redis: kill -9 PID号 | redis-cli -p 6379 shutdown

4. Redis入门案例

4.1 引入jar包文件

        <!--spring整合redis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>
 

4.2 编辑测试API

package com.jt.test;

import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;

public class TestRedis {

    /**
     * 1.测试redis程序链接是否正常
     * 步骤:
     *      1.实例化jedis工具API对象(host:port)
     *      2.根据实例 操作redis  方法就是命令
     *
     * 关于链接不通的说明:
     *      1.检查Linux防火墙
     *      2.检查Redis配置文件修改项
     *          2.1 IP绑定
     *          2.2 保护模式
     *          2.3 后台启动
     *      3.检查redis启动方式  redis-server redis.conf
     *      4.检查IP 端口 及redis是否启动...
     *
     *      */
    @Test
    public void test01(){
        String host = "192.168.126.129";
        int port = 6379;
        Jedis jedis = new Jedis(host,port);
        jedis.set("cgb2006","好好学习 天天向上");
        System.out.println(jedis.get("cgb2006"));

        //2.练习是否存在key
        if(jedis.exists("cgb2006")){
            jedis.del("cgb2006");
        }else{
            jedis.set("cgb2006", "xxxx");
            jedis.expire("cgb2006", 100);
        }

    }
}

作业

1.预习其他的命令 代码和命令
2.回顾AOP的知识

 

 

<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.jt.dubbo</groupId>
   <artifactId>dubbo-jt</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>pom</packaging>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.3.4.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <java.version>1.8</java.version>
      <!--添加maven插件 -->
      <maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
   </properties>

   <dependencies>
      <!--springBoot动态的引入springMVC全部的配置 -->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <!--引入测试类 -->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>

      <!--添加属性注入依赖 -->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-configuration-processor</artifactId>
         <optional>true</optional>
      </dependency>

      <!--支持热部署 -->
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>springloaded</artifactId>
         <version>1.2.8.RELEASE</version>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-devtools</artifactId>
      </dependency>

      <!--引入插件lombok 自动的set/get/构造方法插件 -->
      <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
      </dependency>

      <!--引入数据库驱动 -->
      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <scope>runtime</scope>
      </dependency>

      <!--引入druid数据源 -->
      <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>druid</artifactId>
         <version>1.1.12</version>
      </dependency>

      <!--spring整合mybatis-plus -->
      <dependency>
         <groupId>com.baomidou</groupId>
         <artifactId>mybatis-plus-boot-starter</artifactId>
         <version>3.0.6</version>
      </dependency>

      <!--spring整合redis -->
      <dependency>
         <groupId>redis.clients</groupId>
         <artifactId>jedis</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.data</groupId>
         <artifactId>spring-data-redis</artifactId>
      </dependency>

      <!--springBoot整合JSP添加依赖 -->
      <!--servlet依赖 注意与eureka整合时的问题 -->
      <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>javax.servlet-api</artifactId>
      </dependency>

      <!--jstl依赖 -->
      <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>jstl</artifactId>
      </dependency>

      <!--使jsp页面生效 -->
      <dependency>
         <groupId>org.apache.tomcat.embed</groupId>
         <artifactId>tomcat-embed-jasper</artifactId>
      </dependency>

      <!--添加httpClient jar包 -->
      <dependency>
         <groupId>org.apache.httpcomponents</groupId>
         <artifactId>httpclient</artifactId>
      </dependency>

      <dependency>
         <groupId>com.alibaba.boot</groupId>
         <artifactId>dubbo-spring-boot-starter</artifactId>
         <version>0.2.0</version>
      </dependency>
   </dependencies>
   <modules>
      <module>dubbo-jt-demo-interface</module>
      <module>dubbo-jt-demo-provider</module>
      <module>dubbo-jt-demo-consumer</module>
      <module>dubbo-jt-demo-provider2</module>
   </modules>
</project>

 

<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>
  <parent>
    <groupId>com.jt.dubbo</groupId>
    <artifactId>dubbo-jt</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>dubbo-jt-demo-interface</artifactId>
</project>

 

package com.jt.dubbo.pojo;

import java.io.Serializable;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

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

@Data
@Accessors(chain=true)
@TableName
public class User implements Serializable{ 
                     //dubbo协议中传输的对象必须序列化
   private static final long serialVersionUID = 1L;
   @TableId(type=IdType.AUTO)
   private Integer id;
   private String name;
   private Integer age;
   private String sex;
   
   
}

 

package com.jt.dubbo.service;

import java.util.List;

import org.springframework.transaction.annotation.Transactional;

import com.jt.dubbo.pojo.User;
//service只负责方法的定义，不负责方法的实现，提供者实现接口
public interface UserService {
   
   //查询全部的用户信息
   List<User> findAll();
   //新增用户入库操作.
   @Transactional
   void saveUser(User user);
}

 

<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>
  <parent>
    <groupId>com.jt.dubbo</groupId>
    <artifactId>dubbo-jt</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>dubbo-jt-demo-provider</artifactId>
  <dependencies>
      <!--依赖公共的接口项目-->
   <dependency>
      <groupId>com.jt.dubbo</groupId>
      <artifactId>dubbo-jt-demo-interface</artifactId>
      <version>0.0.1-SNAPSHOT</version>
   </dependency>
  </dependencies>
</project>

 

server:
  port: 9000   #定义端口

spring:
  datasource:
    #引入druid数据源
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/jtdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    username: root
    password: root

#关于Dubbo配置   
dubbo:
  scan:
    basePackages: com.jt    #指定dubbo的包路径 扫描dubbo注解
  application:              #应用名称
    name: provider-user     #一个接口对应一个服务名称 一个接口可以有多个实现
  registry: #注册中心 用户获取数据从从机中获取 主机只负责监控整个集群 实现数据同步
    address: zookeeper://192.168.126.129:2181?backup=192.168.126.129:2182,192.168.126.129:2183
  protocol:  #指定协议
    name: dubbo  #使用dubbo协议(tcp-ip)  web-controller直接调用sso-Service
    port: 20880  #每一个服务都有自己特定的端口 不能重复.

      
mybatis-plus:
  type-aliases-package: com.jt.dubbo.pojo       #配置别名包路径
  mapper-locations: classpath:/mybatis/mappers/*.xml  #添加mapper映射文件
  configuration:
    map-underscore-to-camel-case: true                #开启驼峰映射规则

 

<?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.jt.dubbo.mapper.UserMapper">

</mapper>

 

package com.jt;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.jt.dubbo.mapper")
public class SpringBoot_Run {
   
   public static void main(String[] args) {
      
      SpringApplication.run(SpringBoot_Run.class, args);
   }
}

 

package com.jt.dubbo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.dubbo.pojo.User;

public interface UserMapper extends BaseMapper<User>{
   
}

 

package com.jt.dubbo.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import com.alibaba.dubbo.config.annotation.Service;
import com.jt.dubbo.mapper.UserMapper;
import com.jt.dubbo.pojo.User;
@Service(timeout=3000) //3秒超时 内部实现了rpc
//@org.springframework.stereotype.Service//将对象交给spring容器管理
public class UserServiceImpl implements UserService {
   
   @Autowired
   private UserMapper userMapper;
   
   @Override
   public List<User> findAll() {
      
      System.out.println("我是第一个服务的提供者");
      return userMapper.selectList(null);
   }
   
   @Override
   public void saveUser(User user) {
      
      userMapper.insert(user);
   }
}

 

<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>
  <parent>
    <groupId>com.jt.dubbo</groupId>
    <artifactId>dubbo-jt</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>dubbo-jt-demo-provider2</artifactId>
  <dependencies>
   <dependency>
      <groupId>com.jt.dubbo</groupId>
      <artifactId>dubbo-jt-demo-interface</artifactId>
      <version>0.0.1-SNAPSHOT</version>
   </dependency>
  </dependencies>
</project>

 

server:
  port: 9003

spring:
  datasource:
    #引入druid数据源
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/jtdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    username: root
    password: root
    
dubbo:
  scan:
    basePackages: com.jt
  application:
    name: provider-user
  registry:
    address: zookeeper://192.168.126.129:2181?backup=192.168.126.129:2182,192.168.126.129:2183
  protocol:
    name: dubbo
    port: 20882 #每个服务都应该有自己独立的端口

      
mybatis-plus:
  type-aliases-package: com.jt.dubbo.pojo       #配置别名包路径
  mapper-locations: classpath:/mybatis/mappers/*.xml  #添加mapper映射文件
  configuration:
    map-underscore-to-camel-case: true                #开启驼峰映射规则

 

<?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.jt.dubbo.mapper.UserMapper">

</mapper>

 

package com.jt;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.jt.dubbo.mapper")
public class SpringBoot_Run {
   
   public static void main(String[] args) {
      
      SpringApplication.run(SpringBoot_Run.class, args);
   }
}

 

package com.jt.dubbo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.dubbo.pojo.User;

public interface UserMapper extends BaseMapper<User>{
   
}

 

package com.jt.dubbo.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import com.alibaba.dubbo.config.annotation.Service;
import com.jt.dubbo.mapper.UserMapper;
import com.jt.dubbo.pojo.User;
@Service(timeout=3000) //3秒超时 
public class UserServiceImpl implements UserService {
   
   @Autowired
   private UserMapper userMapper;
   @Override
   public List<User> findAll() {
      System.out.println("我是第二个服务提供者");
      return userMapper.selectList(null);
   }
   
   @Override
   public void saveUser(User user) {
      
      userMapper.insert(user);
   }

}

 

<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>
  <parent>
    <groupId>com.jt.dubbo</groupId>
    <artifactId>dubbo-jt</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>dubbo-jt-demo-consumer</artifactId>
  <dependencies>
   <dependency>
      <groupId>com.jt.dubbo</groupId>
      <artifactId>dubbo-jt-demo-interface</artifactId>
      <version>0.0.1-SNAPSHOT</version>
   </dependency>
  </dependencies>
</project>

 

server:
  port: 9001
dubbo:
  scan:
    basePackages: com.jt
  application:
    name: consumer-user   #定义消费者名称
  registry:               #注册中心地址
    address: zookeeper://192.168.126.129:2181?backup=192.168.126.129:2182,192.168.126.129:2183

 

package com.jt;

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

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

 

package com.jt.dubbo.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.alibaba.dubbo.config.annotation.Reference;
import com.jt.dubbo.pojo.User;
import com.jt.dubbo.service.UserService;

@RestController
public class UserController {
   
   //利用dubbo的方式为接口创建代理对象 利用rpc调用
   
   //@Reference(loadbalance = "random")//负载均衡随机策略
   //@Reference(loadbalance = "roundrobin")//轮询方式
   //@Reference(loadbalance = "consistenthash")//一致性hash 消费者绑定服务器提供者
   @Reference(loadbalance = "leastactive")//挑选当前负载小的服务器进行访问
   private UserService userService; 
   
   /**
    * Dubbo框架调用特点:远程RPC调用就像调用自己本地服务一样简单
    * @return
    */
   @RequestMapping("/findAll")
   public List<User> findAll(){
      
      //远程调用时传递的对象数据必须序列化.
      return userService.findAll();
   }
   
   @RequestMapping("/saveUser/{name}/{age}/{sex}")
   public String saveUser(User user) {
      
      userService.saveUser(user);
      return "用户入库成功!!!";
   }
}