负载均衡---点两次刷新一个数据库

于 2023-06-29 22:08:14 发布
阅读量107 收藏
点赞数
文章标签： 负载均衡 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_53755109/article/details/131464852
版权

 上一篇写了Eureka插件的具体内容，本篇不在赘述。

这篇主要是创建提供者8001、8002、8003。

提供者主要有一下构成

 

 

 第一步：创建  DeptProvider8002_App启动类    @EnableEurekaClient是关联Eureka的注解

package com.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

//启动类
@SpringBootApplication
@EnableEurekaClient
public class DeptProvider8002_App {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider8002_App.class,args);
    }
}

第二步：创建DeptDao8002 dao层                添加Mapper注解

package com.springcloud.dao;

import com.springcloud.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface DeptDao8002 {
    public List<Dept> selectAll();
}

第三步：创建DeptService8002 服务接口

package com.springcloud.service;

import com.springcloud.pojo.Dept;

import java.util.List;

public interface DeptService8002 {
    public List<Dept> findAll();
}

第四步：创建DeptServiceImpl8002实现类          注解Server   调用dao层

package com.springcloud.service.Impl;

import com.springcloud.dao.DeptDao8002;
import com.springcloud.pojo.Dept;
import com.springcloud.service.DeptService8002;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class DeptServiceImpl8002 implements DeptService8002 {
    //拿到数据据访问层接口
    @Resource
    private DeptDao8002 deptDao8002;

    @Override
    public List<Dept> findAll() {
        return deptDao8002.selectAll();
    }
}

第五步：创建DeptController8002                调用服务层接口

package com.springcloud.controller;

import com.springcloud.pojo.Dept;
import com.springcloud.service.DeptService8002;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;

@RestController
public class DeptController8002 {
    //拿到业务逻辑层接口对象
    @Resource
    private DeptService8002 deptService8002;

    @RequestMapping("showAll")
    public List<Dept> showAll(){
        List<Dept> list=deptService8002.findAll();
        return list;
    }
}

第六步：修改yml文件

server:
  port: 8002    #修改端口号
mybatis:    #加载mybatis中的配置文件
  config-location: classpath:mybatis\mybatis.cfg.xml
  type-aliases-package: com.springcloud.pojo    #实体类
  mapper-locations: classpath:mybatis\mapper\DeptMapper.xml
spring:     #给当前项目取别名
  application:
    name: wangxunbo
  datasource:   #连接数据库
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3308/clouddb02
    username: root
    password: 1234
eureka:   ##把Eureka客户端关联当前项目中
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka
  instance:   #起别名
    instance-id: wangxunbo8002
    prefer-ip-address: true   #显示IP地址
info: #补充摘要信息
    app.name: wangxunbo
    company.name: www.wxb.com
    build.artifactId: @project.artifactId@
    build.version: @project.version@

第七步：配置mybatis.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>

第八步：配置mapper缓存文件用于sql语句。

<?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.springcloud.dao.DeptDao8002">
    <select id="selectAll" resultType="com.springcloud.pojo.Dept">
        select * from dept;
    </select>
</mapper>

第九步：配置整个文件的pom.xml文件。

<dependencies>
        <!--引入自己定义的api通用包，可以使用Dept部门Entity-->
        <dependency>
            <groupId>com.springcloud</groupId>
            <artifactId>microservicecloud-api</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!--actuator(驱动器）完善监控信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!-- 将微服务provider注册进eureka -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </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-starter-test</artifactId>
        </dependency>
        <!-- 修改后立即生效，热部署 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>springloaded</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

第十步：在消费者上（8080）上配置 因为这是在地址栏上跳转的。  配置整个文件的pom.xml文件

 

 <dependency>
            <groupId>org.springframework.cloud</groupId>
            <!-- eureka后面没有根server，说明此处是客户端，而Ribbon是处理客户端负载均衡，所以此处需要eureka客户端的jar包 -->
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>
        <!-- Eureka与 config是关联关系，所以此处需要config的jar包-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>

在ConfigBean上编写。  LoadBalanced注解的意思是负载平衡。

package com.springcloud.cfgbeans;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

//配置类
//这个相当于Web.xml文件的整个部分
@Configuration
public class ConfigBean {
    //这个Bean相当于是bean里面的ID
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate(){
        //创建restTemplate对象，通过这个对象，来调用提供者子项目中查询方法
        RestTemplate restTemplate = new RestTemplate();
       // 微服务之间通过谁调用呢？答：restTemplate
        return restTemplate;
    }
    @Bean
    public IRule getFzjh(){
        //RandomRule randomRule = new RandomRule();  //随机
         RandomRule_XQQ randomRule_xqq = new RandomRule_XQQ();
        return randomRule_xqq;
        //return randomRule;
    }
}

 第二个Bean注解之下的语句是刷新两次的方法。

第十一步：创建RandomRule_XQQ类继承AbstractLoadBalancerRule

package com.springcloud.cfgbeans;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

import java.util.List;

public class RandomRule_XQQ extends AbstractLoadBalancerRule {

    //声明一个变量，用来存放负载均衡请求的总次数
    private int total=0;
    //声明一个变量，用来存放具体请求的索引编号
    private int currentIndex=0;
    /**
     * 从IRule接口“随机算法实现类”中方法，直接复制过的
     * @param lb
     * @param key
     * @return
     */
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;
        System.out.println("server的值:"+server);
        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            System.out.println("lb:"+lb);
            List<Server> upList = lb.getReachableServers();
            System.out.println("upList的值："+upList);
            List<Server> allList = lb.getAllServers();
            System.out.println("allList："+allList);
            int serverCount = allList.size();
            System.out.println("serverCount的值："+serverCount);
            if (serverCount == 0) {
                return null;
            }
            /**
             *   判断请求的次数是否为两次，如果不够2次，继续请求，
             *   如果够2次，清空为0，从下一个服务器开始，继续请求
             */
            if (total<2){
                System.out.println("total加之前:"+total);
                System.out.println("if中的currentIndex:"+currentIndex);
                //把当前的机器号赋值给当前服务，让其显示1号机器对应的信息，赋值给server
                server = upList.get(currentIndex);
                total++;
                System.out.println("total加之后:"+total);
            }else{
                total=0;
                currentIndex++;
                System.out.println("else中的currentIndex:"+currentIndex);
                if(currentIndex>=upList.size()){
                    currentIndex=0;
                }
            }
            if (server == null) {
                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }
            server = null;
            Thread.yield();
        }
        return server;
    }
    /**
     * 自动重写的方法，暂时不需要
     * @param iClientConfig
     */
    @Override
    public void initWithNiwsConfig(IClientConfig iClientConfig) {

    }

    @Override
    public Server choose(Object key) {
        //this.getLoadBalancer()是调用父项目中get方法
        Server server = this.choose(this.getLoadBalancer(), key);
        return server;
    }
}

第十二步：配置application.yml文件 ，此处fetch-registry为true原因是消费者类不能和提供者类抢占页面。

server:
  port: 8080
eureka:
  client:
    fetch-registry: true  #这个要拒绝连接因为每个这能有一个端口 我们不会把消费者项目注册进到Eureka
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/     	#负载均衡是建立在Eureka集群的基础上

到此为止，结束！

talent'T1000
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值