@EnableDiscoveryClient

package com.y.config;

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;

/**
 * @program: cloud-demo
 * @description: 获取注册的服务
 * @author: ChestnutDuck
 * @create: 2023-11-23 19:45
 **/
@Configuration
public class webconfig {
    @LoadBalanced  //负载均衡 我们有两个服务节点 通过这个去处理
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate(); //底层其实就是发请求给对应的服务器
    }
}

package com.y.wen.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.Map;

/**
 * @program: cloud-demo
 * @description: 消费端测试访问resfood
 * @author: ChestnutDuck
 * @create: 2023-11-23 19:32
 **/
@RequestMapping("order")
@RestController
@Slf4j
public class ordercontoller {
    @Autowired
    public RestTemplate restTemplate;
    @RequestMapping(value = "addCart",method = {RequestMethod.POST})
    public Map<String, Object> addCart(@RequestParam Integer fid, @RequestParam Integer num, HttpSession httpSession){
        Map<String,Object> map=new HashMap<>();
        Map <String,Object> result = this.restTemplate.getForObject("http://localhost:9001/food/findByFid?fid=" + fid,Map.class );
        log.info("发送请求后得到商品信息"+result);
        return map;
    }
}

@Configuration
public class webconfig {
    @LoadBalanced  //负载均衡 我们有两个服务节点 通过这个去处理
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate(); //底层其实就是发请求给对应的服务器
    }
}

@RequestMapping("order")
@RestController
@Slf4j
public class ordercontoller {
    @Autowired
    public RestTemplate restTemplate; //springboot里的
    @RequestMapping(value = "addCart",method = {RequestMethod.POST})
    public Map<String, Object> addCart(@RequestParam Integer fid, @RequestParam Integer num, HttpSession httpSession){
        String url="http://resfood/food/findByFid?fid=";
        //                  服务名   请求前缀       参数(根据自己传参的方式选择是否加这个)
        Map<String,Object> map=new HashMap<>();
//        http://192.168.118.162:9000/food/findByFid?fid= 使用ip和端口固定访问一个服务
        Map <String,Object> result = this.restTemplate.getForObject(url + fid,Map.class );
        log.info("发送请求后得到商品信息"+result);
        return map;
    }
}

package com.y.config;

import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.DefaultResponse;
import org.springframework.cloud.client.loadbalancer.EmptyResponse;
import org.springframework.cloud.client.loadbalancer.Request;
import org.springframework.cloud.client.loadbalancer.Response;
import org.springframework.cloud.loadbalancer.core.NoopServiceInstanceListSupplier;
import org.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;
import org.springframework.cloud.loadbalancer.core.SelectedInstanceCallback;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import reactor.core.publisher.Mono;

import java.util.List;
import java.util.Random;

/**
 * @program: cloud-demo
 * @description: 参照官方定义的类自定义的负载均衡器
 * @author: ChestnutDuck
 * @create: 2023-11-24 20:50
 **/
public class OnlyOneLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    String serviceId;
    ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
    public OnlyOneLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider){
        this.serviceInstanceListSupplierProvider=serviceInstanceListSupplierProvider;
    }
    public OnlyOneLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider, String serviceId) {
        this.serviceId=serviceId;
        this.serviceInstanceListSupplierProvider=serviceInstanceListSupplierProvider;
    }

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        ServiceInstanceListSupplier supplier = (ServiceInstanceListSupplier)this.serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);
        return supplier.get(request).next().map((serviceInstances) -> {
            return this.processInstanceResponse(supplier, serviceInstances);
        });
    }

    private Response<ServiceInstance> processInstanceResponse(ServiceInstanceListSupplier supplier, List<ServiceInstance> serviceInstances) {
        Response<ServiceInstance> serviceInstanceResponse = this.getInstanceResponse(serviceInstances);
        if (supplier instanceof SelectedInstanceCallback && serviceInstanceResponse.hasServer()) {
            ((SelectedInstanceCallback)supplier).selectedServiceInstance((ServiceInstance)serviceInstanceResponse.getServer());
        }

        return serviceInstanceResponse;
    }

    private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {
        if (instances.isEmpty()) {
            return new EmptyResponse();
        } else {
            ServiceInstance instance = (ServiceInstance)instances.get(0);
            return new DefaultResponse(instance);
        }
    }
}

package com.y.config;

import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClient;
import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClientConfiguration;
import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClients;
import org.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;

/**
 * @program: cloud-demo
 * @description: 托管
 * @author: ChestnutDuck
 * @create: 2023-11-25 08:49
 **/
@Configuration

public class MyLoadBalanceConfig {
    @Bean
    public ReactorServiceInstanceLoadBalancer myOnlyOneReactorServiceInstanceLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        //随机RandomLoadBalancer；轮询RoundRobinLoadBalancer
        return new OnlyOneLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class));
    }
}

@LoadBalancerClients(
        value = {             @LoadBalancerClient(value = "resfood", configuration = MyLoadBalanceConfig.class)
        }, defaultConfiguration = LoadBalancerClientConfiguration.class
)
//defaultConfiguration 默认方案使用轮询

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

package com.y;

/**
 * @program: cloud-demo
 * @description:
 * @author: ChestnutDuck
 * @create: 2023-11-25 10:04
 **/
public class Test {
    public static void main(String[] args) {
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        Hello target=new HelloImpl();//目标类
        CustomInvocationHandler handler=new CustomInvocationHandler(target);
        //生成代理对象
        Object proxy=handler.createProxy();
        System.out.println(proxy); //Proxy代理对象
        Hello hi=(Hello) proxy ;//hi==proxy
        hi.sayHello();
        hi.sayBye();
    }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.sun.proxy;

import com.y.Hello;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Hello {
    private static Method m1; //这是被代理接口的方法，接口有几个代理对象里就有几个
    private static Method m4;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
            
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void sayHello() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
            //这里的h就是传进来的InvocationHandler对象 
           //调用的其实还是 CustomInvocationHandler的invoke
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void sayBye() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m4 = Class.forName("com.y.Hello").getMethod("sayHello");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.y.Hello").getMethod("sayBye");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

public interface FeignService {
  // @Headers
  @RequestLine("GET /api/documents/{contentType}")
  @Headers("Accept: {contentType}")
  String getDocumentByType(@Param("contentType") String type);
  
  // @QueryMap: Map or POJO
  @RequestLine("GET /find")
  V find(@QueryMap Map<String, Object> queryMap);
  @RequestLine("GET /find")
  V find(@QueryMap CustomPojo customPojo);
  
  // @HeaderMap: Map
  @RequestLine("POST /")
  void post(@HeaderMap Map<String, Object> headerMap);
    
  // @Body
  @RequestLine("POST /")
  @Headers("Content-Type: application/xml")
  @Body("<login \"user_name\"=\"{user_name}\" \"password\"=\"{password}\"/>")
  void xml(@Param("user_name") String user, @Param("password") String password);
 
  @RequestLine("POST /")
  @Headers("Content-Type: application/json")
  @Body("%7B\"user_name\": \"{user_name}\", \"password\": \"{password}\"%7D")
  void json(@Param("user_name") String user, @Param("password") String password);
}

package com.y.api;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.Map;

/**
 * @program: cloud-demo
 * @description: 食物所有的api，测试openfeign
 * @author: ChestnutDuck
 * @create: 2023-11-25 11:16
 **/
@FeignClient("resfood")
public interface ResFoodApi {
    //这里的路径多带food 是因为注册服务的对应控制类上加了RequestMapping("food") 多加了一层访问路径
    @RequestMapping("food/detailCountAdd")
    public Map<String,Object> detailCountAdd(Integer fid);
    @RequestMapping("food/findAll")

    public Map<String,Object> findAll();

    @RequestMapping("food/findByFid")
    public Map<String,Object> findById(@RequestParam Integer fid);
    @RequestMapping(value = "food/findByPage",method =RequestMethod.POST)
    public Map<String,Object> findByPage(@RequestParam int pageno,@RequestParam int pagesize,
                                         @RequestParam String sortby,@RequestParam String sort);

}

package com.y;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

/**
 * @program: cloud-demo
 * @description: 订单启动类
 * @author: ChestnutDuck
 * @create: 2023-11-22 20:24
 **/
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients(basePackages= {"com.y.api"}) //暴露api的包路径
public class ResOrderApp {
    public static void main(String[] args) {
        SpringApplication.run(ResOrderApp.class,args);
    }
}

package com.y.web.controller;

import com.y.api.ResFoodApi;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.Map;

/**
 * @program: cloud-demo
 * @description: 消费端测试访问resfood
 * @author: ChestnutDuck
 * @create: 2023-11-23 19:32
 **/
@RequestMapping("order")
@RestController
@Slf4j
public class ordercontoller {
    @Autowired
    public ResFoodApi resFoodApi;
    @Autowired
    public RestTemplate restTemplate; //springboot里的
    @RequestMapping(value = "addCart",method = {RequestMethod.POST})
    public Map<String, Object> addCart(@RequestParam Integer fid, @RequestParam Integer num, HttpSession httpSession){
        Map<String,Object> map=new HashMap<>();
         //       第一种： http://192.168.118.162:9000/food/findByFid?fid= 使用ip和端口固定访问一个服务
        //第二种：
//        String url="http://resfood/food/findByFid?fid=";
//      //                  服务名   请求前缀
//        Map <String,Object> result = this.restTemplate.getForObject(url + fid,Map.class );
        Map<String,Object> result=this.resFoodApi.findById(fid); 
        log.info("发送请求后得到商品信息"+result);
        return map;
    }
}

@RefreshScope

package com.y.config;

import com.alibaba.druid.pool.DruidDataSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;

/**
 * @program: cloud-demo
 * @description:
 * @author: ChestnutDuck
 * @create: 2023-11-30 22:58
 **/
@Configuration
@Slf4j
@RefreshScope 
public class MyDruidDataSource {
    @Value("${spring.datasource.url}")
    private String url;
    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
    @Value("${spring.datasource.username}")
    private String username;
    @Value("${spring.datasource.password}")
    private String password;

    @Bean  //IOC
    @Primary  //优先使用这个代码IOC
    @RefreshScope
    public DataSource druid(){
        log.info("使用的编程式的数据源创建.");
        DruidDataSource ds=new DruidDataSource();
        ds.setUsername(username);
        ds.setPassword(password);
        ds.setDriverClassName(this.driverClassName);
        ds.setUrl(url);
        return  ds;
    }
}

    public static void main(String[] args) {
        //配置流控规则
        initFlowRules();
        //模拟访问 while（true）
        while(true){
            //1.5.0 版本开始可以直接利用 try-with-resources 特性
            try(Entry entry= SphU.entry("HelloWorld")){
                //被保护的逻辑
                System.out.println("要执行的操作。。。");

            } catch (BlockException e) {
//                throw new RuntimeException(e);
                System.out.println("blocked!");
            }
        }

private static void initFlowRules(){
    List<FlowRule> rules = new ArrayList<>(); //规则列表
    FlowRule rule = new FlowRule();
    rule.setResource("HelloWorld"); //此规则对那个资源起作用
    rule.setGrade(RuleConstant.FLOW_GRADE_QPS); //每秒钟请求数
    // Set limit QPS to 20.
    rule.setCount(100000); //每秒多少个请求
    rules.add(rule);
    FlowRuleManager.loadRules(rules); //添加规则到规则管理器
}

@SpringBootApplication
public class Application {

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

@Service
public class TestService {
	//业务层
    @SentinelResource(value = "sayHello")
    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

@RestController
public class TestController {
	//控制层
    @Autowired
    private TestService service;

    @GetMapping(value = "/hello/{name}")
    public String apiHello(@PathVariable String name) {
        return service.sayHello(name);
    }
}

    @Autowired
    public GoodsBiz goodsBiz;
    @RequestMapping(value = "serviceA",method = RequestMethod.GET)
    public Map<String,Object> serviceA(){
        Map<String,Object> map=new HashMap<>();
        goodsBiz.goodsInfo();
        map.put("code",200);
        return map;
    }
    @RequestMapping(value = "serviceB",method = RequestMethod.GET)
    public Map<String,Object> serviceB(){
        Map<String,Object> map=new HashMap<>();
        goodsBiz.goodsInfo();
        map.put("code",200);
        return map;
    }

@Service
public class GoodsBiz {
    @SentinelResource("goodsInfo") //将此方法定义为sentinel管理的资源
    public void goodsInfo(){
        System.out.println("商品信息");
    }
}

@GetMapping("payAction")
   public Map<String,Object> payAction(Integer flag) throws InterruptedException {
       if (flag==null){
           Thread.sleep(3000);
       }
       Map<String, Object> map = new HashMap<>();
       map.put("code",200);
       return map;
   }

@GetMapping("payAction")
   public Map<String,Object> payAction(Integer flag) throws InterruptedException {
       Random r=new Random();
       int a= r.nextInt(5);
       if (a==2||a==4){
           //40%的异常
                   throw new RuntimeException("我要异常咯");
       }
       Map<String, Object> map = new HashMap<>();
       map.put("code",200);
       return map;
   }

blockHandler = "回调函数的名字"

  @SentinelResource(value = "hotkey-page",blockHandler = "handleBlock")
    @RequestMapping(value = "/findByPage",method = {RequestMethod.POST,RequestMethod.GET})
    public Map<String,Object> findByPage(@RequestParam int pageno,@RequestParam int pagesize,
                                         @RequestParam String sortby,@RequestParam String sort)
        
//对应的回调函数
	 public Map<String, Object> handleBlock(int pageno, int pagesize, String sortby, String sort , BlockException exception) {
        exception.printStackTrace();
        Map<String, Object> map = new HashMap<>();
        map.put("code", 0);
        String info ="exception:"+exception.getMessage()+", rule:"+exception.getRule();
        map.put("msg",info);
        return map;

package com.y.config;

import org.springframework.core.annotation.Order;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.Map;

/**
 * @program: cloud-demo
 * @description: springBoot 针对业务异常的统一处理切面
 * @author: ChestnutDuck
 * @create: 2023-12-11 20:42
 **/
@ControllerAdvice    //  Controller控制器,ioc,     Advice: aop中的增强
@Order(-100000) //一个连接点可以加很多增强，这个表示他在那一层，把他设置成-100000，表示他在最高层，里面的异常一层一层往出抛，到这里集中处理
//   AOP技术
public class CustomerExceptionHandlerAdvice {

    public class CustomerExceptionHandler {
        @ExceptionHandler(RuntimeException.class) //dao->service(事务回滚针对RuntimeException)->controller->advice
        @ResponseBody
        public Map<String,Object> handleRuntimeException(RuntimeException exception){
            Map<String,Object> map=new HashMap<>();
            map.put("code",0);
            map.put("msg","runtimeException occured"+exception.getMessage());
            return map;
        }
    }
}

	package com.y.config;

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import com.alibaba.csp.sentinel.slots.system.SystemBlockException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

/**
 * @program: cloud-demo
 * @description: sentinel异常BlockException及子类(各种流控异常) 同义转换处理
 * @author: ChestnutDuck
 * @create: 2023-12-11 21:10
 **/
@Component
public class MySentinelExceptionHandler implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, BlockException ex) throws Exception {
        String msg = null;
        if (ex instanceof FlowException) {
            msg = "访问频繁，请稍候再试";
        } else if (ex instanceof DegradeException) {
            msg = "系统降级";
        }else if( ex instanceof ParamFlowException){
            msg="热点参数异常:"+   ex.getMessage()+","+((ParamFlowException) ex).getResourceName()+","+ex.getRule() ;
        }


        else if (ex instanceof SystemBlockException) {
            msg = "系统规则限流或降级";

        } else if (ex instanceof AuthorityException) {
            msg = "授权规则不通过";

        } else {
            msg = "未知限流降级";
        }
        // http状态码
        response.setStatus(200);
        response.setCharacterEncoding("utf-8");
        response.setHeader("Content-Type", "application/json;charset=utf-8");
        response.setContentType("application/json;charset=utf-8");
        Map map=new HashMap();
        map.put("code",0);
        map. put("msg", msg);
//ObjectMapper 将map对象转为json对象
        ObjectMapper om=new ObjectMapper();
        String json=om.writeValueAsString(   map );
        PrintWriter writer=response.getWriter();
        writer.write(   json  );
        writer.flush();
    }

}