yaml复制代码docker run --name zookeeper-rpc-demo --restart always -p 8080:8080 -p 2181:2181 -p 2888:2888 -p 3888:3888  -d zookeeper

vbnet复制代码This image includes EXPOSE 2181 2888 3888 8080 (the zookeeper client port, follower port, election port, AdminServer port respectively), so standard container linking will make it automatically available to the linked containers. Since the Zookeeper "fails fast" it's better to always restart it.

bash复制代码docker exec -it fb6f95cde6ba /bin/bash

java复制代码public interface HelloService {
    String hello(String msg);
}

java复制代码public interface HiService {
    String hi(String msg);
}

java复制代码/**
 * @author yano
 * GitHub 项目： https://github.com/LjyYano/Thinking_in_Java_MindMapping
 * @date 2021-05-07
 */
@RpcServer(cls = HelloService.class)
public class HelloServiceImpl implements HelloService {

    @Override
    public String hello(String msg) {
        return "hello echo: " + msg;
    }
}

java复制代码/**
 * @author yano
 * GitHub 项目： https://github.com/LjyYano/Thinking_in_Java_MindMapping
 * @date 2021-05-07
 */
@RpcServer(cls = HiService.class)
public class HiServiceImpl implements HiService {

    public String hi(String msg) {
        return "hi echo: " + msg;
    }
}

java复制代码@SpringBootApplication
public class RpcServerApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(RpcServerApplication.class)
                .web(WebApplicationType.NONE)
                .run(args);
    }
}

java复制代码@Component
public class NettyApplicationContextAware implements ApplicationContextAware {

    private static final Logger logger = LoggerFactory.getLogger(NettyApplicationContextAware.class);

    @Value("${zk.address}")
    private String zookeeperAddress;

    @Value("${zk.port}")
    private int zookeeperPort;

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, Object> rpcBeanMap = new HashMap<>();
        for (Object object : applicationContext.getBeansWithAnnotation(RpcServer.class).values()) {
            rpcBeanMap.put("/" + object.getClass().getAnnotation(RpcServer.class).cls().getName(), object);
        }
        try {
            NettyServer.start(zookeeperAddress, zookeeperPort, rpcBeanMap);
        } catch (Exception e) {
            logger.error("register error !", e);
        }
    }
}

java复制代码@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target(ElementType.TYPE)
@Component
public @interface RpcServer {

    /**
     * 接口类，用以接口注册
     */
    Class<?> cls();

}

java复制代码public class NettyServer {

    private static final Logger logger = LoggerFactory.getLogger(NettyServer.class);

    public static void start(String ip, int port, Map<String, Object> params) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .option(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        protected void initChannel(SocketChannel socketChannel) {
                            socketChannel.pipeline()
                                    .addLast(new RpcDecoder(Request.class))
                                    .addLast(new RpcEncoder(Response.class))
                                    .addLast(new RpcServerInboundHandler(params));
                        }
                    });

            ChannelFuture future = serverBootstrap.bind(ip, port).sync();
            if (future.isSuccess()) {
                params.keySet().forEach(key -> ZooKeeperOp.register(key, ip + ":" + port));
            }
            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

}

java复制代码params.keySet().forEach(key -> ZooKeeperOp.register(key, ip + ":" + port));

java复制代码public class ZooKeeperOp {

    private static final String zkAddress = "localhost:2181";
    private static final ZkClient zkClient = new ZkClient(zkAddress);

    public static void register(String serviceName, String serviceAddress) {
        if (!zkClient.exists(serviceName)) {
            zkClient.createPersistent(serviceName);
        }
        zkClient.createEphemeral(serviceName + "/" + serviceAddress);
        System.out.printf("create node %s \n", serviceName + "/" + serviceAddress);
    }

    public static String discover(String serviceName) {
        List<String> children = zkClient.getChildren(serviceName);
        if (CollectionUtils.isEmpty(children)) {
            return "";
        }
        return children.get(ThreadLocalRandom.current().nextInt(children.size()));
    }
}

java复制代码public class RpcClientApplication {

    public static void main(String[] args) {
        HiService hiService = RpcProxy.create(HiService.class);
        String msg = hiService.hi("msg");
        System.out.println(msg);

        HelloService helloService = RpcProxy.create(HelloService.class);
        msg = helloService.hello("msg");
        System.out.println(msg);
    }
}

bash复制代码hi echo: msg
hello echo: msg

java复制代码HiService hiService = RpcProxy.create(HiService.class);
String msg = hiService.hi("msg");

java复制代码public class RpcProxy {

    public static <T> T create(final Class<?> cls) {
        return (T) Proxy.newProxyInstance(cls.getClassLoader(), new Class<?>[] {cls}, (o, method, objects) -> {

            Request request = new Request();
            request.setInterfaceName("/" + cls.getName());
            request.setRequestId(UUID.randomUUID().toString());
            request.setParameter(objects);
            request.setMethodName(method.getName());
            request.setParameterTypes(method.getParameterTypes());

            Response response = new NettyClient().client(request);
            return response.getResult();
        });
    }
}

java复制代码@Data
public class Request {

    private String requestId;
    private String interfaceName;
    private String methodName;
    private Class<?>[] parameterTypes;
    private Object parameter[];

}

java复制代码Response response = new NettyClient().client(request);

java复制代码/**
 * @author yano
 * GitHub 项目： https://github.com/LjyYano/Thinking_in_Java_MindMapping
 * @date 2021-05-07
 */
public class NettyClient extends SimpleChannelInboundHandler<Response> {

    private Response response;

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        ctx.close();
    }

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, Response response) {
        this.response = response;
    }

    public Response client(Request request) throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            // 创建并初始化 Netty 客户端 Bootstrap 对象
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel channel) {
                            channel.pipeline()
                                    .addLast(new RpcDecoder(Response.class))
                                    .addLast(new RpcEncoder(Request.class))
                                    .addLast(NettyClient.this);
                        }
                    });

            // 连接 RPC 服务器
            String[] discover = ZooKeeperOp.discover(request.getInterfaceName()).split(":");
            ChannelFuture future = bootstrap.connect(discover[0], Integer.parseInt(discover[1])).sync();

            // 写入 RPC 请求数据并关闭连接
            Channel channel = future.channel();
            channel.writeAndFlush(request).sync();
            channel.closeFuture().sync();

            return response;
        } finally {
            group.shutdownGracefully();
        }
    }

}

java复制代码channel.pipeline()
    .addLast(new RpcDecoder(Response.class))
    .addLast(new RpcEncoder(Request.class))
    .addLast(NettyClient.this);

java复制代码public class RpcDecoder extends MessageToMessageDecoder<ByteBuf> {

    private final Class<?> genericClass;

    public RpcDecoder(Class<?> genericClass) {
        this.genericClass = genericClass;
    }

    @Override
    public void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) {
        if (msg.readableBytes() < 4) {
            return;
        }
        msg.markReaderIndex();
        int dataLength = msg.readInt();
        if (msg.readableBytes() < dataLength) {
            msg.resetReaderIndex();
            return;
        }
        byte[] data = new byte[dataLength];
        msg.readBytes(data);

        out.add(JSON.parseObject(data, genericClass));
    }
}

java复制代码public class RpcEncoder extends MessageToByteEncoder {

    private final Class<?> genericClass;

    public RpcEncoder(Class<?> genericClass) {
        this.genericClass = genericClass;
    }

    @Override
    public void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out) {
        if (genericClass.isInstance(msg)) {
            byte[] data = JSON.toJSONBytes(msg);
            out.writeInt(data.length);
            out.writeBytes(data);
        }
    }
}

java复制代码socketChannel.pipeline()
    .addLast(new RpcDecoder(Request.class))
    .addLast(new RpcEncoder(Response.class))
    .addLast(new RpcServerInboundHandler(params));

java复制代码@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    Request request = (Request) msg;
    logger.info("request data {}", JSON.toJSONString(request));

    // jdk 反射调用
    Object bean = handle.get(request.getInterfaceName());
    Method method = bean.getClass().getMethod(request.getMethodName(), request.getParameterTypes());
    method.setAccessible(true);
    Object result = method.invoke(bean, request.getParameter());

    Response response = new Response();
    response.setRequestId(request.getRequestId());
    response.setResult(result);

    // client 接收到信息后主动关闭掉连接
    ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
}

bash复制代码create node /com.yano.service.HelloService/127.0.0.1:3000 
create node /com.yano.service.HiService/127.0.0.1:3000

bash复制代码[zk: 0.0.0.0:2181(CONNECTED) 0] ls /com.yano.service.HelloService
[127.0.0.1:3000]
[zk: 0.0.0.0:2181(CONNECTED) 1] ls /com.yano.service.HiService
[127.0.0.1:3000]

yaml复制代码spring:
  cloud:
    function:
      definition: consumerEvent

yaml复制代码spring:
  cloud:
    stream:
      bindings:
        consumerEvent-in-0:
          destination: DEMO
          group: demo-group

java复制代码// 第一种方式(官方推荐)
@Bean
public Function<Flux<Message<String>>, Mono<Void>> consumerEvent() {
    return flux -> flux.map(message -> {
        System.out.println(message.getPayload());
        return message;
    }).then();
}

// 第二种方式
// 注意使用Flux 要调用 subscribe 不然这个方法不会被消费
@Bean
public Consumer<Flux<Message<String>>> consumerEvent() {
    return flux -> flux.map(message -> {
        System.out.println(message.getPayload());
        return message;
    }).subscribe();
}
// 或
@Bean
public Consumer<Message<String>> consumerEvent() {
    return message -> System.out.println(message.getPayload());
}

java复制代码@Configuration
public class EventSender {
    @Bean
    public Demo demo() {
        return new Demo();
    }

    static class Demo implements CommandLineRunner {
        @Autowired
        StreamBridge streamBridge;

        @Override
        public void run(String... args) throws Exception {
            final Message<T> message = MessageBuilder.withPayload("Body")
                .setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON)
                .build();

            // 第一个配置的是目的地
            // 如果在yaml中有配置会发送到yaml中目的地
            streamBridge.send("DEMO", message);
        }
    }
}

yaml复制代码spring:
  application:
    name: demo
  cloud:
    stream:
      rocketmq:
        binder:
          name-server: 127.0.0.1:9876
          group: demo
      bindings:
        consumerEvent-in-0:
          destination: DEMO
          content-type: application/json
          group: demo-group
      function:
        definition: consumerEvent

java复制代码@Configuration
public class EventReceptor {
    @Bean
    public Function<Flux<Message<String>>, Mono<Void>> consumerEvent() {
        return flux -> flux.map(message -> {
            System.out.println(message.getPayload());
            return message;
        }).then();
    }
}

pom复制代码<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-dependencies</artifactId>
    <version>2020.0.2</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2.2.5-RocketMQ-RC1</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bootstrap</artifactId>
    <version>3.0.2</version>
</dependency>

java复制代码this.pushConsumer.subscribe(this.topic, RocketMQUtils.getMessageSelector(((RocketMQConsumerProperties)this.extendedConsumerProperties.getExtension()).getSubscription()));

public static MessageSelector getMessageSelector(String expression) {
    return StringUtils.hasText(expression) && expression.startsWith("sql:") ? MessageSelector.bySql(expression.replaceFirst("sql:", "")) : MessageSelector.byTag(expression);
}

yaml复制代码// 新版 (现在的写法)
rocketmq:
  bindings:
    createUserAccountEvent-in-0:
      consumer:
        subscription: DEMO-TAG

// 旧版 (以前的写法)
rocketmq:
  bindings:
    createUserAccountEvent-in-0:
      consumer:
        tag: DEMO-TAG

http复制代码Accept: */*
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Connection: keep-alive
Content-Length: 6028
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Cookie: shshshfpb=sJZnAsUTcZJjuNedVMhztBA%3D%3D; 
Host: reg.jd.com
Origin: https://reg.jd.com
Referer: https://reg.jd.com/reg/person?ReturnUrl=https%3A//www.jd.com/
sec-ch-ua: "Google Chrome";v="89", "Chromium";v="89", ";Not A Brand";v="99"
sec-ch-ua-mobile: ?0
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 11_2_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.128 Safari/537.36
X-Requested-With: XMLHttpRequest

http复制代码uuid: 68455e864c894bda845de413849204d0
authCodeStrategy: 1  (验证码策略)
phone: +00861553605xxxx（手机号）
mobileCode: 116547（手机验证码）
regName: demo83520（注册的用户名）
email: xxx@163.com（注册邮箱）
mailCode: 661591（邮箱验证码）
pwd: MvaEqtzkZ4/R4P3wMoRIuZpA4egWYBmz7bikspIWRYwozJgOHJQlQW8POp8elFhi7OXchoz1OPRoFwxqjWpwcWQCUABx5oovhFxLZ0p8CqB3s0lNDz9QlF8ZYMBanwk+Cne4mXMOTop9OGD8XF8YPqb4qkox8A=（密码加密字符串）

bash复制代码export NVM_DIR="$HOME/.nvm"
[ -s "$(brew --prefix nvm)/nvm.sh" ] && . "$(brew --prefix nvm)/nvm.sh"  # This loads nvm

bash复制代码source ~/.zshrc   # 如果你使用的是zsh
source ~/.bashrc  # 如果你使用的是bash

rust复制代码nvm list //查看已存在的node版本
nvm install 8.0.0 //安装node版本
nvm use 8.0.0 //切换node版本环境
nvm uninstall 8.0.0 //卸载

scss复制代码npm install --save-dev nodemon //安装

less复制代码// 配置文件
nodemon [your node app]

json复制代码npm install --save-dev cross-env //安装

//配置文件
{
  "scripts": {
    "build": "cross-env NODE_ENV=production webpack --config build/webpack.config.js"
  }
}

bash复制代码redis-server.exe redis.windows.conf //window下启动redis
redis-cli.exe -h 127.0.0.1 -p 6379 //执行redis语句（set/get）

ini复制代码server {
  #*********nginx监听的端口在这里设置**********
        listen       8088; 
        server_name  localhost;
        #charset koi8-r;
        #access_log  logs/host.access.log  main;

 # *********这里是修改代理指向***********
        #location / {
        #    root   html;
        #    index  index.html index.htm;
        #}
        location / {
        proxy_pass http://localhost:8001;
        }
        location /api/ {
        proxy_pass http://localhost:8000;
        proxy_set_header Host $host;
        }
}

makefile复制代码D:\soft\nginx>cd nginx-1.16.0
D:\soft\nginx\nginx-1.16.0>

yaml复制代码D:\soft\nginx\nginx-1.16.0>netstat -ano |findstr 8080
  TCP    0.0.0.0:8080           0.0.0.0:0              LISTENING       15448 //被进程15448占用
  TCP    10.200.22.57:55155     101.89.15.106:8080     ESTABLISHED     2088
  TCP    10.200.22.57:55228     59.37.96.203:8080      ESTABLISHED     5812

arduino复制代码D:\soft\nginx\nginx-1.16.0>tasklist |findstr 15448
node.exe                     15448 Console                    2     30,252 K

* fs.writeFile //写入文件

* fs.exists // 判断文件是否存在

以上node操作文件的api，都是一次性读完、写完，如果文件过大，会很影响效率。


#### 2. IO操作的性能瓶颈


IO包括“网络IO”和“文件IO”。相比于CPU计算和内存读写，IO的突出特点就是：慢。


#### 3. stream


node已经完成了对stream功能的api实现:**req具有pipe()**，以流的形式，更合理的读文件、写文件。
以下是利用stream，合理的进行IO操作：

#### 4. readline


readline 模块提供了一个接口，用于一次一行地读取可读流（例如 process.stdin）中的数据。


**总结：**



> * 日志对server的重要性
> * IO性能瓶颈，使用stream提高性能
> * 使用crontab拆分日志文件，使用readline分析日志内容


七、项目安全
------


* sql注入： 窃取数内容
* XSS攻击：窃取前端的cookie内容
* 密码加密：保障用户信息


#### 1. sql注入


sql是最原始、最简单的攻击，从有了web2.0就有了sql注入攻击。



> 攻击方式：输入一个sql片段，最终拼接成一段攻击代码
> 
> 
> 预防措施：使用mysql的escape函数处理输入内容即可。
> 执行sql注入攻击的效果：

![](https://gitee.com/songjianzaina/juejin_p9/raw/master/img/8521348a16ae80bc7fcd27e9fe5263040b836cfeac1dfce202f9c4637b5e98b1)
攻击者可以任意操作数据库。


#### 2. XSS攻击



> 攻击方式：在页面展示内容中参杂js代码，以获取网页信息
> 
> 
> 预防措施：转换生成JS的特殊字符
> 使用XSS处理输入的内容

On Node.js

#### 3. 密码加密


数据库被用户攻破，最不应该泄密的就是用户信息。



> 攻击方式：用户用户名和密码，在去尝试登陆其他系统
> 
> 
> 预防措施：将密码加密，即便拿到密码，也不知道明文密码


使用md5加密，如下：

#### 4. 项目总结



> * 处理http接口 //rquest，cookie，处理路由等
> * 连接数据库
> * 实现登录 //session，redis，
> * 安全
> * 日志 //stram，readline


**项目总流程图如下：**
![](https://gitee.com/songjianzaina/juejin_p9/raw/master/img/dc2395fcb7d624c1eada3a9ca11f8cc47c4928d7859ad517b8e2480b7f15d952)


八、express
---------


#### 1、安装


1. express脚手架安装
链接：[expressjs.com/en/starter/…](https://expressjs.com/en/starter/generator.html)
`npm install -g express-generator`
2. 实现登陆需要两个包


* express-session安装
链接：[github.com/expressjs/s…](https://github.com/expressjs/session)
`npm install express-session`
* connect-redis安装
链接：[github.com/tj/connect-…](https://github.com/tj/connect-redis)
`npm install connect-redis express-session`


#### 2、express的中间件概念

#### 3、总结


* 初始化代码中，各个插件的作用
* express如何处理路由
* express中间件


九、koa2
------


#### 1. 为什么使用koa2



> express 中间件是异步回调，koa2原生支持async/await
> 新开发的框架和系统，都是基于koa2，例如egg.js
> express虽为过时，但是koa2是未来趋势


#### 2. `async/await` 要点：



> 1.`await` 后面可以追加promise对象，获取`resolve`的值
> 2.`await`必须包裹在`async`函数里面
> 3`.async`函数执行返回的也是一个`promise`对象
> 4.`try-catch`获取`promise`中`reject`的值

#### 3. koa脚手架安装【koa1和koa2通用】

基于脚手架创建koa1项目：

基于脚手架创建koa2项目：

#### 4. 实现登陆需要两个包

#### 5. 路由


（1）xss 安装: 预防xss攻击

（2）MySQL安装

（3）morgan和koa-morgan： 打印日志
express支持morgan，不支持koa。koa需要安装中间件，`koa-morgan`

#### 6. koa2中间件原理


十、上线与配置
-------


* 服务器稳定性
* 充分利用服务器硬件资源
* 线上日志记录


#### 1. PM2


简单介绍：


* 进程守护，系统崩溃自动重启
* 启动多进程，充分利用CPU和内存
* 自带日志记录功能


（1）下载

（2）常用命令

![](https://gitee.com/songjianzaina/juejin_p9/raw/master/img/f2a3317b13b22655b78b4e1f6416e182c2fe641582b170171932e3033e5214b8)
（3）进程守护


* `node app.js` 和`nodemon app.js`，进程崩溃则不能访问
* pm2遇到进程崩溃，会自动重启
（4）PM2配置
pm2的配置文件：

xml复制代码<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>shardingsphere-jdbc-core</artifactId>
    <version>5.0.0-alpha</version>
</dependency>

java复制代码@Configuration
public class DatabaseConfig {

    /**
     * 方式一 : 通过 Bean 配置
     */
    @Bean
    public DataSource dataSource() {
        // 配置真实数据源
        Map<String, DataSource> dataSourceMap = new HashMap<>();

        // 配置第 1 个数据源
        BasicDataSource dataSource1 = new BasicDataSource();
        dataSource1.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource1.setUrl("jdbc:mysql://127.0.0.1:3306/database0?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=UTC");
        dataSource1.setUsername("root");
        dataSource1.setPassword("123456");
        dataSourceMap.put("ds0", dataSource1);

        // 配置第 2 个数据源
        BasicDataSource dataSource2 = new BasicDataSource();
        dataSource2.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource2.setUrl("jdbc:mysql://127.0.0.1:3306/database1?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=UTC");
        dataSource2.setUsername("root");
        dataSource2.setPassword("123456");
        dataSourceMap.put("ds1", dataSource2);

        // 配置 t_order 表规则
        ShardingTableRuleConfiguration orderTableRuleConfig = new ShardingTableRuleConfiguration("t_blog", "ds${0..1}.t_blog_${0..1}");

        // 配置主键生成策略
        KeyGenerateStrategyConfiguration configuration = new KeyGenerateStrategyConfiguration("id", null);
        orderTableRuleConfig.setKeyGenerateStrategy(configuration);

        // 配置分库策略
        orderTableRuleConfig.setDatabaseShardingStrategy(new StandardShardingStrategyConfiguration("column_id", "dbShardingAlgorithm"));

        // 配置分表策略
        orderTableRuleConfig.setTableShardingStrategy(new StandardShardingStrategyConfiguration("title_id", "tableShardingAlgorithm"));

        // 配置分片规则
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        shardingRuleConfig.getTables().add(orderTableRuleConfig);

        // 配置分库算法
        Properties dbShardingAlgorithmrProps = new Properties();
        dbShardingAlgorithmrProps.setProperty("algorithm-expression", "ds${column_id % 2}");
        shardingRuleConfig.getShardingAlgorithms().put("dbShardingAlgorithm", new ShardingSphereAlgorithmConfiguration("INLINE", dbShardingAlgorithmrProps));

        // 配置分表算法
        Properties tableShardingAlgorithmrProps = new Properties();
        tableShardingAlgorithmrProps.setProperty("algorithm-expression", "t_blog_${title_id % 2}");
        shardingRuleConfig.getShardingAlgorithms().put("tableShardingAlgorithm", new ShardingSphereAlgorithmConfiguration("INLINE", tableShardingAlgorithmrProps));

        DataSource dataSource = null;
        try {
            dataSource = ShardingSphereDataSourceFactory.createDataSource(dataSourceMap, Collections.singleton(shardingRuleConfig), new Properties());
        } catch (SQLException e) {
            e.printStackTrace();
        }
        //logger.info("datasource : {}", dataSource);
        return dataSource;
    }
}

java复制代码@Entity
@Table(name = "t_blog")
public class BlogEntity {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "title")
    private String title;

    @Column(name = "title_id")
    private Integer titleId;

    @Column(name = "author")
    private String author;

    @Column(name = "date")
    private Date date;

    @Column(name = "column_id")
    private Integer columnId;
    
    //.......................
}

java复制代码Caused by: java.lang.reflect.InvocationTargetException: null
	at org.apache.shardingsphere.spring.boot.util.PropertyUtil.v2(PropertyUtil.java:111) ~[shardingsphere-jdbc-spring-boot-starter-infra-5.0.0-alpha.jar:5.0.0-alpha]
	at org.apache.shardingsphere.spring.boot.util.PropertyUtil.handle(PropertyUtil.java:75) ~[shardingsphere-jdbc-spring-boot-starter-infra-5.0.0-alpha.jar:5.0.0-alpha]
	at org.apache.shardingsphere.spring.boot.datasource.DataSourceMapSetter.getDataSourceMap(DataSourceMapSetter.java:66) ~[shardingsphere-jdbc-spring-boot-starter-infra-5.0.0-alpha.jar:5.0.0-alpha]

// 可以看到 , 出问题的地方为 org.apache.shardingsphere.spring.boot.util.PropertyUtil.v2

// 往上2步 , 可以跟踪到节点 : getDataSourceMap
// 这里就是我们第一个要看的地方 : 多数据源的加载


// 先看下异常的原因 , 再看看整体逻辑
public static Map<String, DataSource> getDataSourceMap(final Environment environment) {
    Map<String, DataSource> result = new LinkedHashMap<>();
    Map<String, Object> dataSourceCommonProps = PropertyUtil.handle(environment, COMMON_PREFIX, Map.class);

//...

}


// 基本上可以按出来 , 这里缺少 COMMON_PREFIX 打头的配置项 , 查了相关资料 ,大概是这2句 
spring.shardingsphere.datasource.common.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.common.driver-class-name=com.mysql.jdbc.Driver

// 问题解决 , 看看整体逻辑

java复制代码// 核心的配置加载来自于 org.apache.shardingsphere.spring.boot 包下 , 配置了如下
C10- SpringBootConfiguration 
    F01- SpringBootPropertiesConfiguration : 该类种只有一个 Properties 属性
    F02- Map<String, DataSource> dataSourceMap : 维护了一个 DataSource 的列表
    M10_01- shardingSphereDataSource
        - ShardingSphereDataSourceFactory.createDataSource : 传入 Map 集合创建 DataSource -> M11_01
    M10_02- ShardingTransactionTypeScanner : 事务相关
        
C11- ShardingSphereDataSourceFactory : Datasource 的工厂类
	M11_01- createDataSource(Map<String, DataSource>,Collection<RuleConfiguration>, Properties)
            ?- 创建一个 DataSource , 可以看到 , 这里传入的是一个 DataSource 的集合 , 盲猜原理是创建一个虚拟的DataSource
            ?- Map<String, DataSource> -> PS_M11_01_1
            - new ShardingSphereDataSource(dataSourceMap, configurations, props) -> C12MC
            
// M11_01 代码
public static DataSource createDataSource(final DataSource dataSource, final Collection<RuleConfiguration> configurations, final Properties props) throws SQLException {
    Map<String, DataSource> dataSourceMap = new HashMap<>(1, 1);
    dataSourceMap.put(DefaultSchema.LOGIC_NAME, dataSource);
    return createDataSource(dataSourceMap, configurations, props);
}
            
            
// 由 M11_01 中构建相关对象
C12- ShardingSphereDataSource
    MC- ShardingSphereDataSource
        - 生成一个 DatabaseType -> M12_01
        - 构建一个 SchemaContextsBuilder
        - 构建一个 TransactionContexts
    M12_01- createDatabaseType(final Map<String, DataSource> dataSourceMap)
    	FOR- 对 dataSourceMap 循环 , 分别调用 createDatabaseType -> M12_02
    	- 返回的是最后一个 DataSource 的 DatabaseType 
            ?- 这里的 FOR 循环目的是什么 ? 既然返回的一定是最后一个 , 那循环那么多干嘛
    M12_02- createDatabaseType(final DataSource dataSource)
    	?- 注意 , 这里是2个参数不同的方法
            - dataSource.getConnection() : 获取 Connect 
            - 生成 DatabaseType
    
// M12_02伪代码  : 通过 DatabaseTypeRegistry 获取 DatabaseType , 此处拿到的是 MySQLDatabaseType 
private DatabaseType createDatabaseType(final DataSource dataSource) throws SQLException {
    if (dataSource instanceof ShardingSphereDataSource) {
        return ((ShardingSphereDataSource) dataSource).schemaContexts.getDatabaseType();
    }
    try (Connection connection = dataSource.getConnection()) {
        return DatabaseTypeRegistry.getDatabaseTypeByURL(connection.getMetaData().getURL());
    }
}

java复制代码
// 此处为 dataSourceMap , 用于扫描配置中的数据源 ,起点逻辑为 :

// PS : 该方法为 EnvironmentAware 接口的实现方法 , 会在ApplicationContextAwareProcessor 中默认调用
public final void setEnvironment(final Environment environment) {
    dataSourceMap.putAll(DataSourceMapSetter.getDataSourceMap(environment));
}


// 扫描具体的 DataSource
C- DataSourceMapSetter
    F- private static final String PREFIX = "spring.shardingsphere.datasource.";
    F- private static final String COMMON_PREFIX = "spring.shardingsphere.datasource.common.";
    M1- getDataSourceMap
        - 获取 Common 属性 : spring.shardingsphere.datasource.common.
        - 获取 Srouce 名称集合 -> M2
        - 依次生成 DataSource 放入集合 -> M3
    M2- getDataSourceNames : 获取 datasource Name , 名称为拼接出来的
        - 优先获取 spring.shardingsphere.datasource.name
        - 没有则获取 spring.shardingsphere.datasource.names
    M3- getDataSource 
        - Map<String, Object> dataSourceProps = mergedDataSourceProps(...) : 生成属性
        - Preconditions.checkState(...) : 校验参数是否合法
        - DataSourceUtil.getDataSource(...) : 创建 DataSource
        - 后面是一个语法糖 , 用于注入属性 -> PS_M3_001
    
// PS_M3_001 : 最终执行语句就是 HikariDataSourcePropertiesSetter # propertiesSet
// 会获取 Environment 中 spring.shardingsphere.datasource.ds1.data-source-properties 前缀 , 设置相关属性
DataSourcePropertiesSetterHolder.getDataSourcePropertiesSetterByType(dataSourceProps.get(DATA_SOURCE_TYPE).toString()).ifPresent(propsSetter -> propsSetter.propertiesSet(environment, prefix, dataSourceName, result));

java复制代码// Step 1 : PreparedStatement  # checkBounds
// 异常栈第一步就是这里 , 发现校验出现问题 , 抛出了异常
if ((paramIndex < 1)) {
    throw SQLError.createSQLException(........);
} else if (paramIndex > this.parameterCount) {
    throw SQLError.createSQLException(.......);    
}........
    
    
// Step 2 : 排查 PreparedStatement 初始化方法
C- PreparedStatement    
    M-initializeFromParseInfo()
    	- 观察 staticSqlStrings 发现 , 参数是错误的 , 只有一个数组
insert into org.apache.shardingsphere.sharding.rewrite.token.pojo.TableToken@3df8c40 (author, column_id, date, title, title_id, id) values org.apache.shardingsphere.sharding.rewrite.token.pojo.ShardingInsertValuesToken@c1b5afe
// 此处发现这个值也是错误的 , 猜测应该是 分表时 , table 处理出现异常
    
    
// Step 3 : 排查分表的逻辑
C79- ShardingRouteEngine
    M79_05- route0
        - routeDataSources 获取策略判断的 DataSource 节点
        - routeTables 获取判断的 table 表

// StandardShardingStrategy # doSharding
target = shardingAlgorithm.doSharding(availableTargetNames, new PreciseShardingValue(shardingValue.getTableName(), shardingValue.getColumnName(), each));

// 这里 debug 发现 shardingValue.getTableName() 名称不对 -------> dt_blog_1 , 应该是t_blog_1
// 我的天.....这一看就是配置问题了 , 检查一下
spring.shardingsphere.rules.sharding.sharding-algorithms.db-algorithm.props.algorithm-expression=dt_blog_$->{title_id % 2}

// 改为 
spring.shardingsphere.rules.sharding.sharding-algorithms.db-algorithm.props.algorithm-expression=t_blog_$->{title_id % 2}

// 一个通过源码排查异常的流程旧结束了 , 重新

java复制代码
// 配置映射
C- YamlShardingStrategyConfiguration
	?- 数据配置在上一步被配置到当前的 Configuration , 可以通过该类中的属性进行直接配置 

// Rule 规则
C- ShardingRuleSpringBootConfiguration
     
C- ShardingRuleAlgorithmProviderConfigurationYamlSwapper

C- ShardingTableRuleConfigurationYamlSwapper
    
// algorithm-expression 的注入位置
C- ShardingRule
    M- ShardingRule(final AlgorithmProvidedShardingRuleConfiguration config, final Collection<String> dataSourceNames)

java复制代码C74- ShardingSpherePreparedStatement
    M74_01- executeUpdate() : 执行插入操作 
        ?- 这个里面有3个核心操作 , 获取需要执行的 statement + update 执行语句
        - createExecutionContext 创建一个 ExecutionContext  -> M74_03
            ?- 核心逻辑 , 生成需要执行的对象 ExecuteUnit
        - getInputGroups 获取一个 StatementExecuteUnit 集合 -> M74_02
        - preparedStatementExecutor.executeUpdate 执行当前语句
    M74_02- getInputGroups()
        ?- 核心逻辑就是通过相关的 rule 规则生成对应的执行语句
        - 构建一个 PreparedStatementExecuteGroupEngine
        - 调用 PreparedStatementExecuteGroupEngine generate 方法获取数据 
            ?- 参数一 : executionContext.getRouteContext() 
            ?- 参数二 : executionContext.getExecutionUnits() -> PS:M74_02_01
    M74_03- createExecutionContext()
        - kernelProcessor.generateExecutionContext 生成 ExecutionContext -> M75_01
        - findGeneratedKey 创建主键
                
    
// M74_02 代码
private Collection<InputGroup<StatementExecuteUnit>> getInputGroups() throws SQLException {
    // 最大连接数
    int maxConnectionsSizePerQuery = schemaContexts.getProps().<Integer>getValue(ConfigurationPropertyKey.MAX_CONNECTIONS_SIZE_PER_QUERY);
    // 
    return new PreparedStatementExecuteGroupEngine(maxConnectionsSizePerQuery, connection, statementOption,
                schemaContexts.getDefaultSchema().getRules()).generate(executionContext.getRouteContext(), executionContext.getExecutionUnits());
}

java复制代码// 该类中只有一个方法
C75- KernelProcessor
    M75_01- generateExecutionContext
        1- 获取 ShardingSphereRule 集合
        2- 创建一个 SQLRouteEngine
        3- 获取一个 SQLStatementContext  : 这里可以映射为一个数据库操作
        4- 获取 RouteContext : 这个对象决定将会执行几个数据库/数据表 -> M76_01
        
// M75_01  
public ExecutionContext generateExecutionContext(final LogicSQL logicSQL, final ShardingSphereSchema schema, final ConfigurationProperties props) {
        // PS:M75_01_01 rule 规则对象
        Collection<ShardingSphereRule> rules = schema.getRules();
        SQLRouteEngine sqlRouteEngine = new SQLRouteEngine(rules, props);
        SQLStatementContext<?> sqlStatementContext = logicSQL.getSqlStatementContext();
        
        // 核心语句 : 获取 RouteContext : 这个对象决定将会执行几个数据库/数据表 -> M76_01
        RouteContext routeContext = sqlRouteEngine.route(logicSQL, schema);
        SQLRewriteEntry rewriteEntry = new SQLRewriteEntry(schema.getMetaData().getSchemaMetaData().getConfiguredSchemaMetaData(), props, rules);
        SQLRewriteResult rewriteResult = rewriteEntry.rewrite(logicSQL.getSql(), logicSQL.getParameters(), sqlStatementContext, routeContext);
        Collection<ExecutionUnit> executionUnits = ExecutionContextBuilder.build(schema.getMetaData(), rewriteResult, sqlStatementContext);
        return new ExecutionContext(sqlStatementContext, executionUnits, routeContext);
}

java复制代码C76- SQLRouteEngine
    M76_01- route : 
        - 创建一个 SQLRouteExecutor 
             ?- 参数 : new PartialSQLRouteExecutor(rules, props) , 这里就将所有的 Rule 注入到体系中了
         - executor.route 调用执行器执行 rule  -> M77_01
                
                
C77- PartialSQLRouteExecutor
    M77_01- route : 终于找到了 , 这里通过 Rule 规则生成相关的 SQLRouter
        - entry.getValue().createRouteContext(logicSQL, schema, entry.getKey(), props) : 核心语句 -> M78_01
            
C78- ShardingSQLRouter
    M78_01- createRouteContext
        - ShardingRouteEngineFactory 构建一个 RouteEngine 并且调用对应 route 方法 -> M79_01
        
C79- ShardingRouteEngine
    M79_01- route(RouteContext routeContext, ShardingRule shardingRule)
        - getDataNodes 获取 Collection<DataNode> : -> M79_03
            ?- 此处的 Node 会用于下面生成 RouteUnit -> PS:M79_01_02
         FOR- 循环获取的 Nodes , 创建 RouteUnit
    M79_02- getDataNodes
        - createShardingStrategy 创建策略
    M79_03- routeByShardingConditions  
        ?- 这里会通过 Condition 不同分别调用2个方法
         - route0 -> M79_05
         - routeByShardingConditionsWithCondition -> M79_04
    M79_04- routeByShardingConditionsWithCondition : 核心逻辑1
        For- 循环所有的 Condition , 获取策略和 ShardingValues 值 , 调用 route0 
    M79_05- route0
        - routeDataSources 获取策略判断的 DataSource 节点
        - routeTables 获取判断的 table 表
     M79_06- routeTables 
        - 这里就会调用对应的 Strategy 策略类
        
// PS : 如果这里发现 TableRule 存在问题 , 可以查看方法 是否存在问题
private Collection<DataNode> getDataNodes(final ShardingRule shardingRule, final TableRule tableRule) {
    ShardingStrategy databaseShardingStrategy = createShardingStrategy(shardingRule.getDatabaseShardingStrategyConfiguration(tableRule), shardingRule.getShardingAlgorithms());
    ShardingStrategy tableShardingStrategy = createShardingStrategy(shardingRule.getTableShardingStrategyConfiguration(tableRule), shardingRule.getShardingAlgorithms());
    if (isRoutingByHint(shardingRule, tableRule)) {
        return routeByHint(tableRule, databaseShardingStrategy, tableShardingStrategy);
    }
    if (isRoutingByShardingConditions(shardingRule, tableRule)) {
        return routeByShardingConditions(shardingRule, tableRule, databaseShardingStrategy, tableShardingStrategy);
    }
    return routeByMixedConditions(shardingRule, tableRule, databaseShardingStrategy, tableShardingStrategy);
}


// M79_03 源代码
private Collection<DataNode> routeByShardingConditions(final ShardingRule shardingRule, final TableRule tableRule, 
                                                           final ShardingStrategy databaseShardingStrategy, final ShardingStrategy tableShardingStrategy) {
    return shardingConditions.getConditions().isEmpty()
        ? route0(tableRule, databaseShardingStrategy, Collections.emptyList(), tableShardingStrategy, Collections.emptyList())
        : routeByShardingConditionsWithCondition(shardingRule, tableRule, databaseShardingStrategy, tableShardingStrategy);
}


C80- StandardShardingStrategy
    M80_01- doSharding

properties复制代码server.port=8085
##Jpa配置
spring.jpa.database=mysql
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=none
# 开启配置
spring.shardingsphere.enabled=true
# 配置真实数据源 ds0,ds1,ds2
spring.shardingsphere.datasource.names=ds0,ds1
spring.shardingsphere.datasource.common.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.common.driver-class-name=com.mysql.jdbc.Driver
# 配置第 1 个数据源
spring.shardingsphere.datasource.ds0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds0.jdbc-url=jdbc:mysql://127.0.0.1:3306/database0?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=UTC
spring.shardingsphere.datasource.ds0.username=root
spring.shardingsphere.datasource.ds0.password=123456
# 配置第 2 个数据源
spring.shardingsphere.datasource.ds1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds1.jdbc-url=jdbc:mysql://127.0.0.1:3306/database1?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&serverTimezone=UTC
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=123456
# 配置表策略 -- ShardingTableRuleConfiguration
spring.shardingsphere.rules.sharding.tables.t_blog.actual-data-nodes=ds$->{0..1}.t_blog_$->{0..1}
# 配置主键策略 -- KeyGenerateStrategyConfiguration
spring.shardingsphere.rules.sharding.tables.t_blog.key-generate-strategy.column=id
spring.shardingsphere.rules.sharding.tables.t_blog.key-generate-strategy.key-generator-name=snowflake
# 配置分表策略 StandardShardingStrategyConfiguration
spring.shardingsphere.rules.sharding.tables.t_blog.binding-tables=t_blog
spring.shardingsphere.rules.sharding.tables.t_blog.table-strategy.standard.sharding-column=title_id
spring.shardingsphere.rules.sharding.tables.t_blog.table-strategy.standard.sharding-algorithm-name=db-algorithm
# 配置分库策略  StandardShardingStrategyConfiguration
spring.shardingsphere.rules.sharding.tables.t_blog.database-strategy.standard.sharding-column=column_id
spring.shardingsphere.rules.sharding.tables.t_blog.database-strategy.standard.sharding-algorithm-name=table-algorithm
# ================================
# =====================配置默认策略
# 默认插入类型
spring.shardingsphere.rules.sharding.default-database-strategy.standard.sharding-column=id
spring.shardingsphere.rules.sharding.default-database-strategy.standard.sharding-algorithm-name=database_inline
# 指定 algorithms
spring.shardingsphere.rules.sharding.sharding-algorithms.database-inline.type=INLINE
spring.shardingsphere.rules.sharding.sharding-algorithms.database-inline.props.algorithm-expression=ds$->{id % 2}
# 默认算法
spring.shardingsphere.rules.sharding.key-generators.snowflake.type=SNOWFLAKE
spring.shardingsphere.rules.sharding.key-generators.snowflake.props.worker-id=123
# 切分策略
spring.shardingsphere.rules.sharding.sharding-algorithms.db-algorithm.type=INLINE
spring.shardingsphere.rules.sharding.sharding-algorithms.db-algorithm.props.algorithm-expression=t_blog_$->{title_id % 2}
spring.shardingsphere.rules.sharding.sharding-algorithms.table-algorithm.type=INLINE
spring.shardingsphere.rules.sharding.sharding-algorithms.table-algorithm.props.algorithm-expression=ds$->{column_id % 2}


# !!!!! 对应表 t_blog_0 , t_blog_1 , 已经上面2个库

java复制代码/**
 * @description: 自定义异常处理
 * @author: DT
 * @date: 2021/4/19 21:17
 * @version: v1.0
 */
@ControllerAdvice
public class MyExceptionHandler {

    @ExceptionHandler(value =Exception.class)
    @ResponseBody
    public String exceptionHandler(Exception e){
        System.out.println("全局异常捕获>>>:"+e);
        return "全局异常捕获,错误原因>>>"+e.getMessage();
    }
}

java复制代码 @GetMapping("/getById/{userId}")
public CommonResult<User> getById(@PathVariable Integer userId){
    // 手动抛出异常
    int a = 10/0;
    return CommonResult.success(userService.getById(userId));
}

java复制代码/**
 * @description: 服务接口类
 * @author: DT
 * @date: 2021/4/19 21:39
 */
public interface BaseErrorInfoInterface {

    /**
     *  错误码
     * @return
     */
    String getResultCode();

    /**
     * 错误描述
     * @return
     */
    String getResultMsg();
}

java复制代码/**
 * @description: 异常处理枚举类
 * @author: DT
 * @date: 2021/4/19 21:41
 * @version: v1.0
 */
public enum ExceptionEnum implements BaseErrorInfoInterface{
    
    // 数据操作错误定义
    SUCCESS("2000", "成功!"),
    BODY_NOT_MATCH("4000","请求的数据格式不符!"),
    SIGNATURE_NOT_MATCH("4001","请求的数字签名不匹配!"),
    NOT_FOUND("4004", "未找到该资源!"),
    INTERNAL_SERVER_ERROR("5000", "服务器内部错误!"),
    SERVER_BUSY("5003","服务器正忙，请稍后再试!");

    /**
     * 错误码
     */
    private final String resultCode;

    /**
     * 错误描述
     */
    private final String resultMsg;

    ExceptionEnum(String resultCode, String resultMsg) {
        this.resultCode = resultCode;
        this.resultMsg = resultMsg;
    }

    @Override
    public String getResultCode() {
        return resultCode;
    }

    @Override
    public String getResultMsg() {
        return resultMsg;
    }
}

java复制代码/**
 * @description: 自定义异常类
 * @author: DT
 * @date: 2021/4/19 21:44
 * @version: v1.0
 */
public class BizException extends RuntimeException{

    private static final long serialVersionUID = 1L;

    /**
     * 错误码
     */
    protected String errorCode;
    /**
     * 错误信息
     */
    protected String errorMsg;

    public BizException() {
        super();
    }

    public BizException(BaseErrorInfoInterface errorInfoInterface) {
        super(errorInfoInterface.getResultCode());
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
    }

    public BizException(BaseErrorInfoInterface errorInfoInterface, Throwable cause) {
        super(errorInfoInterface.getResultCode(), cause);
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
    }

    public BizException(String errorMsg) {
        super(errorMsg);
        this.errorMsg = errorMsg;
    }

    public BizException(String errorCode, String errorMsg) {
        super(errorCode);
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }

    public BizException(String errorCode, String errorMsg, Throwable cause) {
        super(errorCode, cause);
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }


    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }

    public String getErrorMsg() {
        return errorMsg;
    }

    public void setErrorMsg(String errorMsg) {
        this.errorMsg = errorMsg;
    }

    @Override
    public Throwable fillInStackTrace() {
        return this;
    }
}

java复制代码/**
 * @description: 自定义数据传输
 * @author: DT
 * @date: 2021/4/19 21:47
 * @version: v1.0
 */
public class ResultResponse {
    /**
     * 响应代码
     */
    private String code;

    /**
     * 响应消息
     */
    private String message;

    /**
     * 响应结果
     */
    private Object result;

    public ResultResponse() {
    }

    public ResultResponse(BaseErrorInfoInterface errorInfo) {
        this.code = errorInfo.getResultCode();
        this.message = errorInfo.getResultMsg();
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Object getResult() {
        return result;
    }

    public void setResult(Object result) {
        this.result = result;
    }

    /**
     * 成功
     *
     * @return
     */
    public static ResultResponse success() {
        return success(null);
    }

    /**
     * 成功
     * @param data
     * @return
     */
    public static ResultResponse success(Object data) {
        ResultResponse rb = new ResultResponse();
        rb.setCode(ExceptionEnum.SUCCESS.getResultCode());
        rb.setMessage(ExceptionEnum.SUCCESS.getResultMsg());
        rb.setResult(data);
        return rb;
    }

    /**
     * 失败
     */
    public static ResultResponse error(BaseErrorInfoInterface errorInfo) {
        ResultResponse rb = new ResultResponse();
        rb.setCode(errorInfo.getResultCode());
        rb.setMessage(errorInfo.getResultMsg());
        rb.setResult(null);
        return rb;
    }

    /**
     * 失败
     */
    public static ResultResponse error(String code, String message) {
        ResultResponse rb = new ResultResponse();
        rb.setCode(code);
        rb.setMessage(message);
        rb.setResult(null);
        return rb;
    }

    /**
     * 失败
     */
    public static ResultResponse error( String message) {
        ResultResponse rb = new ResultResponse();
        rb.setCode("-1");
        rb.setMessage(message);
        rb.setResult(null);
        return rb;
    }

    @Override
    public String toString() {
        return JSONObject.toJSONString(this);
    }

}

java复制代码/**
 * @description: 自定义异常处理
 * @author: DT
 * @date: 2021/4/19 21:51
 * @version: v1.0
 */
@ControllerAdvice
public class GlobalExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    /**
     * 处理自定义的业务异常
     * @param req
     * @param e
     * @return
     */
    @ExceptionHandler(value = BizException.class)
    @ResponseBody
    public ResultResponse bizExceptionHandler(HttpServletRequest req, BizException e){
        logger.error("发生业务异常！原因是：{}",e.getErrorMsg());
        return ResultResponse.error(e.getErrorCode(),e.getErrorMsg());
    }

    /**
     * 处理空指针的异常
     * @param req
     * @param e
     * @return
     */
    @ExceptionHandler(value =NullPointerException.class)
    @ResponseBody
    public ResultResponse exceptionHandler(HttpServletRequest req, NullPointerException e){
        logger.error("发生空指针异常！原因是:",e);
        return ResultResponse.error(ExceptionEnum.BODY_NOT_MATCH);
    }

    /**
     * 处理其他异常
     * @param req
     * @param e
     * @return
     */
    @ExceptionHandler(value =Exception.class)
    @ResponseBody
    public ResultResponse exceptionHandler(HttpServletRequest req, Exception e){
        logger.error("未知异常！原因是:",e);
        return ResultResponse.error(ExceptionEnum.INTERNAL_SERVER_ERROR);
    }
}

java复制代码@PostMapping("/add")
public boolean add(@RequestBody User user) {
    //如果姓名为空就手动抛出一个自定义的异常！
    if(user.getName()==null){
        throw  new BizException("-1","用户姓名不能为空！");
    }
    return true;
}