网络环境介绍：

公司内网有一台web服务器，地址是192.168.100.100，web服务端口为80，并且为这台web服务器申请了DNS A记录的域名解析服务，解析记录是公司出口ip地址100.100.100.100。在办公区网络环境里，还有内网192.168.10.0网段，需要通过申请的域名来访问公司内网的192.168.100.100的web服务。

做法是在防火墙的出口，做一条端口映射，100.100.100.100:80到192.168.100.100:80的端口映射。

问题来了，做好端口映射以后，其他外部网络通过域名访问公司的web服务是正常的，但是公司内网用户通过域名访问公司自己的web服务，却无法访问；而公司内网用户通过192.168.100.100:80私有地址访问，是正常的。这种情况，就是因为做好端口映射以后，访问web服务的流量在响应的时候流量没有回流到防火墙导致的。

原因分析：

如上图，假如是192.168.10.10通过申请的域名访问192.168.100.100的web服务。这里假设访问的源端口是1234，目标端口是80，数据包分析如下：

PC1主机发起web请求.因为通过域名访问的，DNS解析服务正常，那么访问目标就是100.100.100.100:80

192.168.10.10:1234—>100.100.100.100:80

数据包最终会被路由到防火墙上，防火墙检查访问的目的地址，匹配到它的端口映射策略，将目标地址改为对192.168.100.100的访问，建立起一个针对目标ip地址转换的NAT会话表

192.168.10.10:1234—>192.168.100.100:80

然后数据包到会被转发到192.168.100.100服务器上并会响应192.168.10.10主机的请求，将上述访问的源目ip地址及端口进行倒转，并将数据包交给它的网关处理，图中就是R1路由器

192.168.100.100:80—>192.168.10.10:1234

R1路由器检查访问者的源ip和目标ip地址，发现目标ip地址是192.168.10.10，是R1路由器一个可路由的内网ip地址，就会将数据包直接路由到PC1主机上

PC1主机接收到数据包，检查数据包的源ip和端口是192.168.100.100:80，发现其本身并没有这样一个http会话与之相匹配，就是说PC1主机并没有主动发起对192.168.100.100:80的访问，发起的是对100.100.100.100:80的访问，那么PC1主机就会丢弃这个数据包，导致内网用户通过域名或者公网ip地址访问自己的内网服务器不通的现象。

192.168.100.100:80—>192.168.10.10:1234

上述就是造成我们开头所说问题的原因。发生上述问题的原因，就是因为其R1路由器发现响应数据包的目的ip地址是内网一个可直接路由的地址，就会直接在内网进行路由转发，而不是将数据包交给防火墙进行路由转发。

Acme地址：GitHub

Acme脚本申请证书分为：

• 80端口空闲验证的方式
• Nginx验证的方式
• Http验证的方式
• DNS验证的方式

这里我是用腾讯云的域名DNS来申请证书

效果如图 整个博客全部通过一张证书 实现Https

apesblog.com*.apesblog.com*.frp.apesbog.com

这里（*）泛域名只能对下一级全部域名生效、而不是无限递归

更新环境

apt update -y#Debian/Ubuntu 命令apt install -y curl#Debian/Ubuntu 命令apt install -y socat#Debian/Ubuntu 命令

安装Acme脚本

curl https://get.acme.sh | sh

去腾讯云DNSPOD申请密钥（注意这里是DNS密钥 不是API密钥）

设置环境变量

export DP_Id="xxx"export DP_Key="xxxxxxxxxxxxxxx"

这里不同的DNS服务器 环境变量名不同 查看官方文档：dnsapi · acmesh · GitHub

申请证书

其中dns_dp为 腾讯云DNSPod.服务商,自行根据官方dnsapi修改.例如:dns_ali为阿里云,dns_cf为CloudFlare
Acme可以同时申请多个域名.例如拥有域名只需要在每个域名前加上 -d + 空格 +域名 即可.

~/.acme.sh/acme.sh  --issue --server letsencrypt \--dns dns_dp \-d apesblog.com \-d *.apesblog.com \-d *.frp.apesblog.com

安装证书

~/.acme.sh/acme.sh --installcert -d apesblog.com \--key-file /etc/nginx/conf.d/acme/private.key \--fullchain-file /etc/nginx/conf.d/acme/cert.crt

脚本自动更新

Let’s Encrypt 的证书有效期为三个月.为避免证书失效 Acme 会每60天根据你的历史申请记录和部署记录重新续签证书并部署

由于Acme脚本更新频繁，所以打开自动更新 ，避免续签失败

~/.acme.sh/acme.sh  --upgrade  --auto-upgrade

玩家B长时间不登陆游戏，玩家B可以分享链接给玩家A，玩家A点击链接进入游戏，双方便可获取奖励

Bug

被唤醒玩家B通过玩家A分享的链接登陆，MQ回调以后，查询是否有唤醒任务时，我没加唤醒任务是否已完成这个条件，导致玩家A一直点链接进入游戏，奖励一直发放

前提

• Socket
• IO

思路

• 启动 Socket 服务，循环接收浏览器请求
• 接收到请求之后，将流中的数据取出
• 判断目标资源是否存在，若不存在，返回 404
• 若存在，将目标资源通过输出流响应给客户端

代码

1. Tomcat

   package com.apesblog.tomcat;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.net.ServerSocket;import java.net.Socket;/** * @author ZhangYuShun * @since 2022/8/31 */public class Tomcat {    /**     * 一个简单的Web容器     */    public static void main(String[] args) throws IOException {        //定义ServerSocket8080端口        ServerSocket serverSocket = new ServerSocket(8080);        //循环接受请求        while (true) {            Socket socket = serverSocket.accept();            System.out.println(socket);            new Thread(() -> {                try {                    InputStream inputStream = socket.getInputStream();                    Request request = new Request(inputStream);                    //创建Response                    OutputStream outputStream = socket.getOutputStream();                    Response response = new Response(outputStream);                    //进行响应                    response.sendRedirect(request.getUrl());                } catch (Exception e) {                    e.printStackTrace();                }            }).start();        }    }}

2. Request

   package com.apesblog.tomcat;import java.io.IOException;import java.io.InputStream;/** * @author ZhangYuShun * @since 2022/8/31 */public class Request {    private String url;    private String Method;    public Request(InputStream inputStream) throws IOException {        /**         * 要一次读取多个字节时，经常用到InputStream.available()方法，这个方法可以在读写操作前先得知数据流里有多少个字节可以读取。需要注意的是，如果这个方法用在从本         * 地文件读取数据时，一般不会遇到问题，但如果是用于网络操作，就经常会遇到一些麻烦。         * 比如，Socket通讯时，对方明明发来了1000个字节，但是自己的程序调用available()方法却只得到900，或者100，甚至是0，感觉有点莫名其妙，怎么也找不到原因。         * 其实，这是因为网络通讯往往是间断性的，一串字节往往分几批进行发送。本地程序调用available()方法有时得到0，         * 这可能是对方还没有响应，也可能是对方已经响应了，但是数据还没有送达本地。对方发送了1000个字节给你，也许分成3批到达，         * 这你就要调用3次available()方法才能将数据总数全部得到。         */        int count = 0;        while (count == 0) {            count = inputStream.available();        }        byte[] bytes = new byte[count];        inputStream.read(bytes);        String content = new String(bytes);        System.out.println(content);        if ("".equals(content)) {            System.out.println("空请求");        } else {            //正则\s 转义\            String firstLine = content.split("\\n")[0];            this.setMethod(firstLine.split("\\s")[0]);            this.setUrl(firstLine.split("\\s")[1]);        }    }    public String getUrl() {        return url;    }    public void setUrl(String url) {        this.url = url;    }    public String getMethod() {        return Method;    }    public void setMethod(String method) {        Method = method;    }}

3. Response

   package com.apesblog.tomcat;import java.io.BufferedInputStream;import java.io.File;import java.io.OutputStream;import java.nio.file.Files;public class Response {    private OutputStream outputStream;    public Response(OutputStream outputStream) {        this.outputStream = outputStream;    }    public void sendRedirect(String uri) {        //判断uri是否存在        //不存在返回404        //存在直接返回目标资源数据        File file = new File(Response.class.getResource("/").getPath() + uri);        if (file.exists()) {            try {                //返回目标资源数据                BufferedInputStream bufferedInputStream = new BufferedInputStream(Files.newInputStream(file.toPath()));                //存储每次读取的数据                byte[] bytes = new byte[1024];                //记录每次读取的有效字节个数                int len = 0;                //TODO 感觉写的不好 字节转字符再转字节输出   不够优雅                StringBuilder result = new StringBuilder();                while ((len = bufferedInputStream.read(bytes)) != -1) {                    result.append(new String(bytes, 0, len));                }                String response = getResponseMessage("200", result.toString());                System.out.println(response);                this.outputStream.write(response.getBytes());            } catch (Exception e) {                e.printStackTrace();            }        } else {            try {                //返回404                String error = getResponseMessage("404", "404 File Not Found!");                this.outputStream.write(error.getBytes());            } catch (Exception e) {                e.printStackTrace();            }        }    }    public String getResponseMessage(String code, String message) {        return "HTTP/1.1 " + code + "\r\n" + "Content-type: text/html\r\n" + "Content-Length: " + message.length() + "\r\n" + "\r\n" + message;    }}

不错不错，原来条件注入是这样使用的，之前看组件注册-@Conditional-按照条件注册bean还没有深刻的体会，现在理解了

没有return。。。

原来 Integer.getInteger()

是根据指定的名称得到系统属性的整数值。第一个参数将被认为是系统属性的名称。属性值字符串将被解释成一个

整数，并且以表示这个值的Integer对象形式返回。

需求

聊天功能一共就两张表，一张会话表，一张消息表

我要保证两位玩家之间的会话只有一条

代码贴出来了，如果看不懂，那你可能就需要去了解下prototype和proto了，

https://www.jianshu.com/p/dee9f8b14771

或者去b站看一下pink老师的视频也行

<!DOCTYPE html><html lang="en"><head>   <meta charset="UTF-8">   <meta http-equiv="X-UA-Compatible" content="IE=edge">   <meta name="viewport" content="width=device-width, initial-scale=1.0">   <title>jQuery</title></head><body>   <div id="main">main</div>   <button type="submit" id="btn_submit" onclick="submit()">jQuery</button>   <script>       var Apesblog = function (dom) {           return new Apesblog.prototype.init(dom);       }       Apesblog.prototype = {           // constructor: Apesblog,           init: function (dom) {               if (dom.indexOf("#") == 0) {                   dom = dom.substr(1, dom.length);                   console.log(dom);                   this.elem = document.getElementById(dom);               }               // this.__proto__ = Apesblog.prototype;               console.log(this);           },           css: function (key, value) {               this.elem.style[key] = value;           }       }         Apesblog.prototype.init.prototype =  Apesblog.prototype;       window.apesblog = Apesblog;   </script>   <script>       function submit(){           apesblog("#main").css("color", "red");       }   </script></body></html>

窗口函数很强大，row_number(顺序排序),rank(跳跃排序),dense_rank(连续排序)

MYSQL 8.0

CREATE TABLE IF NOT EXISTS  student(   id varchar(20),-- 编号   class varchar(20),-- 班级   stu_name varchar(20),-- 学生姓名   score int-- 分数);

插入数据:

insert student values('1','classOne','Jack',82);insert student values('2','classOne','Jame',95);insert student values('3','classOne','Toney',82);insert student values('4','classOne','Nike',40);insert student values('5','classOne','Ha',20);insert student values('6','classOne','Tom',95);insert student values('7','classTwo','Elik',40);insert student values('8','classTwo','T',3);insert student values('9','classTwo','Kim',60);insert student values('10','classTwo','Tim',10);insert student values('11','classTwo','Li',95);insert student values('12','classThree','C.Ronaldo',60);insert student values('13','classThree','Messi',40);insert student values('14','classThree','Neymar',90);insert student values('15','classThree','Moyi',20);insert student values('16','classThree','Sun',70);

分组查询每个班级的最高分

SELECTa.* FROMstudent aINNER JOIN ( SELECT max( score ) AS score, class AS class FROM student GROUP BY class ) b ON a.class = b.class AND a.score = b.score SELECT* FROMstudent a WHERE( SELECT count( 1 ) FROM student b WHERE a.class = b.class AND a.score < b.score ) = 0SELECT* FROM( SELECT rank ( ) over ( PARTITION BY class ORDER BY a.score DESC) rownumber, a.* FROM student a ) b WHEREb.rownumber = 1

分页不正常， 总条数是对的。可显示的都是第一页。

bug分析总结：

很明显公司框架，在判断出我传入pageparam为null时，默认查询limit 条数

limit 条数 等同于 limit 0 ,条数

找bug过程很曲折。找到之后我可真是笨比啊。

JdbcTemplate

• JdbcTemplate是Spring对JDBC的封装，目的是使JDBC更加易于使用，JdbcTemplate类通过模板设计模式帮助我们消除了冗长的代码，只做需要做的事情（即可变部分），并且帮我们做哪些固定部分，如连接的创建及关闭。
• 增删改操作不用返回结果集，所以可以抽取成一个方法update()，公司框架传入的形参是update(String sql,Object arg1)，Spring当中是update(String sql, Object… args)。
• 批量增加、删除、更新数据调用batchUpdate()方法。批量操作比for循环单次操作效率高。
• 查询操作调用query()方法因为查询有返回结果集，所以需要传入domain.class。

SpringMVC的执行流程

• 1.用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获。
• 2.DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射。
• 3.如果DispatcherServlet没找到对应的映射则交给DefaultServlet处理，都没找到会展示404。
• 4.开始执行拦截器的preHandler(…)方法(正向)。
• 5.开始执行Controller方法。
• 6.异常处理器（项目中没找到配置）。
• 7.开始执行拦截器的postHandle(…)方法(逆向 )。
• 8.渲染视图完毕执行拦截器的afterCompletion(…)方法(逆向)。

因为在项目中的web.xml中将前端控制器DispatcherServlet的映射请求设置为“/”,所以需要添加 标签用来相应静态文件。
Tomcat容器的web.xml中有一个DefaultServlet(用于处理静态资源)，映射路径是"/“，项目中的web.xml最终相当于会与容器的web.xml合并，而项目DispatchServlet一般也是使用”/"，导致容器中的DefaultServlet被覆盖，从而静态资源请求也会被发送到SpringMVC，SpringMVC会去找这个路径的映射器(相当于对应的Controller，这是找不到的)，配置这个，就是在SpringMVC找不到映射路径后，再将其转给Tomcat的DefaultServlet这是就可以Tomcat就可以正确解析静态资源路径。

package com.apesblog.dao;public interface UserDao {    int add(int a,int b);    int multiply(int a,int b);}package com.apesblog.dao;import org.springframework.stereotype.Repository;@Repositorypublic class UserDaoImpl implements UserDao {    @Override    public int multiply(int a, int b) {        return a * b;    }    @Override    public int add(int a, int b) {        return a + b;    }}

2.MyInvocationHandler

package com.apesblog.dao;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Component;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;@Componentpublic class MyInvocationHandler implements InvocationHandler {    @Autowired    UserDao userDao;    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("----------");        Object invoke = method.invoke(userDao, args);        System.out.println(invoke);        System.out.println("----------");        return invoke;    }}

3.@Configuration或者xml

import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;@Configuration@ComponentScan(basePackages = {"com.apesblog"})public class SpringConfig {}<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:context="http://www.springframework.org/schema/context"       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">    <context:component-scan base-package="com.apesblog"></context:component-scan></beans>

4.测试类

import com.apesblog.dao.MyInvocationHandler;import com.apesblog.dao.UserDao;import org.springframework.context.ApplicationContext;import org.springframework.context.annotation.AnnotationConfigApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import java.lang.reflect.Proxy;public class Test1 {    public static void main(String[] args) {        //xml//        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean1.xml");        //全注解        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);        MyInvocationHandler myInvocationHandler = (MyInvocationHandler) applicationContext.getBean("myInvocationHandler");        Class[] interfaces = {UserDao.class};        UserDao o = (UserDao) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), interfaces, myInvocationHandler);        o.add(1, 2);        o.multiply(1, 2);    }}

1.MyBeanPost后置处理器

package com.apesblog.demo;import org.springframework.beans.BeansException;import org.springframework.beans.factory.config.BeanPostProcessor;public class MyBeanPost implements BeanPostProcessor {    @Override    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {        System.out.println("postProcessBeforeInitialization");        return null;    }    @Override    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {        System.out.println("postProcessAfterInitialization");        return null;    }}

2.User类

package com.apesblog.demo;public class User {    String name;    public User(String name) {        this.name = name;    }    public User() {        System.out.println("执行无参构造");    }    public void setName(String name) {        this.name = name;        System.out.println("执行set方法");    }    public void initMethod(){        System.out.println("initMethod");    }    public void destroyMethod(){        System.out.println("destroyMethod");    }}

3.测试类

package com.apesblog.demo.Test1;import com.apesblog.demo.User;import org.junit.Test;import org.springframework.context.support.ClassPathXmlApplicationContext;public class Test1 {    @Test    public void test1(){        System.out.println("启动服务器");        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("bean1.xml");        System.out.println("-----------");        User user = classPathXmlApplicationContext.getBean("user", User.class);        System.out.println(user);        System.out.println("-----------");        User user1 = classPathXmlApplicationContext.getBean("user", User.class);        System.out.println(user1);        classPathXmlApplicationContext.close();    }}

结果（单例xml）

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">    <bean id="user" class="com.apesblog.demo.User" init-method="initMethod" destroy-method="destroyMethod" scope="singleton">        <property name="name" value="apesblog"></property>    </bean>    <bean id="mybeanpost" class="com.apesblog.demo.MyBeanPost"></bean></beans>

结果（多例xml）

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="user" class="com.apesblog.demo.User" init-method="initMethod" destroy-method="destroyMethod" scope="prototype">    <property name="name" value="apesblog"></property></bean><bean id="mybeanpost" class="com.apesblog.demo.MyBeanPost"></bean></beans>

总结：

ClassPathXmlApplicationContext类会在启动服务器的时候创建好Bean，BeanFactory会在getBean时才创建Bean，但是ClassPathXmlApplicationContext提前创建可能运行时性能上快一点。

单例模式下：

Bean是在启动服务器就创建好的，每次执行getBean返回同一个引用就行，最后再执行destroyMethod方法。

多例模式下：

Bean是在每次执行getBean才创建，但是destroyMethod方法为啥不执行，目前不清楚。

补充：

1. 多实例的时候bean不会随着IOC容器的构建而创建，而是在使用的时候创建的getBean()
2. 多实例的时候，当容器进行关闭的时候，bean实例不会调用destroy方法，说明容器不控制多实例的销毁
3. 多实例的情况下，返回的bean的对象是不一样的

package com.apesblog.jdbcutil1.util;import java.io.InputStream;import java.lang.reflect.Field;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.ResultSetMetaData;import java.sql.SQLException;import java.sql.Statement;import java.util.ArrayList;import java.util.Arrays;import java.util.HashMap;import java.util.List;import java.util.Properties;import java.util.Set;import com.apesblog.jdbcutil1.bean.Order;public class JDBCUtils {    private static Connection getConnection() throws Exception {        // 1.读取配置文件中的4个基本信息        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");        Properties pros = new Properties();        pros.load(is);        String user = pros.getProperty("user");        String password = pros.getProperty("password");        String url = pros.getProperty("url");        String driverClass = pros.getProperty("driverClass");        // 2.加载驱动        Class.forName(driverClass);        // 3.获取连接        Connection conn = DriverManager.getConnection(url, user, password);        return conn;    }    private static void closeResource(Connection conn, Statement ps) {        try {            if (ps != null)                ps.close();        } catch (SQLException e) {            e.printStackTrace();        }        try {            if (conn != null)                conn.close();        } catch (SQLException e) {            e.printStackTrace();        }    }    private static void closeResource(Connection conn, Statement ps, ResultSet rs) {        try {            if (ps != null)                ps.close();        } catch (SQLException e) {            e.printStackTrace();        }        try {            if (conn != null)                conn.close();        } catch (SQLException e) {            e.printStackTrace();        }        try {            if (rs != null)                rs.close();        } catch (SQLException e) {            e.printStackTrace();        }    }    public static void update(String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！        Connection conn = null;        PreparedStatement ps = null;        try {            // 1.获取数据库的连接            conn = JDBCUtils.getConnection();            // 2.预编译sql语句，返回PreparedStatement的实例            ps = conn.prepareStatement(sql);            // 3.填充占位符            for (int i = 0; i < args.length; i++) {                ps.setObject(i + 1, args[i]);// 小心参数声明错误！！            }            // 4.执行            ps.execute();        } catch (Exception e) {            e.printStackTrace();        } finally {            // 5.资源的关闭            JDBCUtils.closeResource(conn, ps);        }    }    public static <T> List<T> query(Class<T> clazz, String sql, Object... args) {        Connection conn = null;        PreparedStatement ps = null;        ResultSet rs = null;        try {            conn = JDBCUtils.getConnection();            ps = conn.prepareStatement(sql);            for (int i = 0; i < args.length; i++) {                ps.setObject(i + 1, args[i]);            }            rs = ps.executeQuery();            // 获取结果集的元数据 :ResultSetMetaData            ResultSetMetaData rsmd = rs.getMetaData();            // 通过ResultSetMetaData获取结果集中的列数            int columnCount = rsmd.getColumnCount();            // 创建集合对象            ArrayList<T> list = new ArrayList<T>();            while (rs.next()) {                T t = clazz.newInstance();                // 处理结果集一行数据中的每一个列:给t对象指定的属性赋值                for (int i = 0; i < columnCount; i++) {                    // 获取列值                    Object columValue = rs.getObject(i + 1);                    // 获取每个列的列名                    // String columnName = rsmd.getColumnName(i + 1);                    String columnLabel = rsmd.getColumnLabel(i + 1);                    // 给t对象指定的columnName属性，赋值为columValue：通过反射                    Field field = clazz.getDeclaredField(columnLabel);                    field.setAccessible(true);                    field.set(t, columValue);                }                list.add(t);            }            return list;        } catch (Exception e) {            e.printStackTrace();        } finally {            JDBCUtils.closeResource(conn, ps, rs);        }        return null;    }    public static void updateDomain(String sql, Object object) {        Connection conn = null;        PreparedStatement ps = null;        Class<? extends Object> clazz = object.getClass();        Field[] fields = clazz.getDeclaredFields();        HashMap<Integer, String> hashMap = new HashMap<Integer, String>();        for (int i = 0; i < fields.length; i++) {            String lowerCase = fields[i].getName().toLowerCase();            int indexOf = sql.indexOf(lowerCase);            if (indexOf == -1)                continue;            hashMap.put(indexOf, fields[i].getName());        }        try {            // 1.获取数据库的连接            conn = JDBCUtils.getConnection();            // 2.预编译sql语句，返回PreparedStatement的实例            ps = conn.prepareStatement(sql);            // 3.填充占位符            int size = hashMap.size();            for (int i = 0; i < size; i++) {// --for() begin                Integer minKey = (Integer) getMinKey(hashMap);                String string = hashMap.get(minKey);                Field field = clazz.getDeclaredField(string);                field.setAccessible(true);                Object value = field.get(object);                if (value == null)                    continue;                ps.setObject(i + 1, value);// 小心参数声明错误！！                hashMap.remove(minKey);            }            // 4.执行            ps.execute();        } catch (Exception e) {            e.printStackTrace();        } finally {            // 5.资源的关闭            JDBCUtils.closeResource(conn, ps);        }    }    public static <T> List<T> queryDomain(Class<T> clazz, String sql, Object object) {        Connection conn = null;        PreparedStatement ps = null;        ResultSet rs = null;        Class<? extends Object> objclazz = object.getClass();        Field[] fields = objclazz.getDeclaredFields();        HashMap<Integer, String> hashMap = new HashMap<Integer, String>();        for (int i = 0; i < fields.length; i++) {            String lowerCase = fields[i].getName().toLowerCase();            int indexOf;            if (sql.indexOf("from") == -1) {                indexOf = sql.substring(sql.indexOf("FROM")).indexOf(lowerCase);            } else {                indexOf = sql.substring(sql.indexOf("from")).indexOf(lowerCase);            }            if (indexOf == -1)                continue;            hashMap.put(indexOf, fields[i].getName());        }        try {            conn = JDBCUtils.getConnection();            ps = conn.prepareStatement(sql);            int size = hashMap.size();            for (int i = 0; i < size; i++) {// --for() begin                Integer minKey = (Integer) getMinKey(hashMap);                String string = hashMap.get(minKey);                Field field = clazz.getDeclaredField(string);                field.setAccessible(true);                Object value = field.get(object);                if (value == null)                    continue;                ps.setObject(i + 1, value);// 小心参数声明错误！！                hashMap.remove(minKey);            }            rs = ps.executeQuery();            // 获取结果集的元数据 :ResultSetMetaData            ResultSetMetaData rsmd = rs.getMetaData();            // 通过ResultSetMetaData获取结果集中的列数            int columnCount = rsmd.getColumnCount();            // 创建集合对象            ArrayList<T> list = new ArrayList<T>();            while (rs.next()) {                T t = clazz.newInstance();                // 处理结果集一行数据中的每一个列:给t对象指定的属性赋值                for (int i = 0; i < columnCount; i++) {                    // 获取列值                    Object columValue = rs.getObject(i + 1);                    // 获取每个列的列名                    // String columnName = rsmd.getColumnName(i + 1);                    String columnLabel = rsmd.getColumnLabel(i + 1);                    // 给t对象指定的columnName属性，赋值为columValue：通过反射                    Field field = clazz.getDeclaredField(columnLabel);                    field.setAccessible(true);                    field.set(t, columValue);                }                list.add(t);            }            return list;        } catch (Exception e) {            e.printStackTrace();        } finally {            JDBCUtils.closeResource(conn, ps, rs);        }        return null;    }    private static Object getMinKey(HashMap<Integer, String> hashMap) {        if (hashMap == null)            return null;        Set<Integer> set = hashMap.keySet();        Object[] obj = set.toArray();        Arrays.sort(obj);        return obj[0];    }}

测试类如下：

package com.apesblog.jdbcutil1.util;import java.util.List;import org.junit.Test;import org.junit.internal.requests.OrderingRequest;import com.apesblog.jdbcutil1.bean.Customer;import com.apesblog.jdbcutil1.bean.Order;public class Test1 {    @Test    public void testUpdateDoamin() {        String sql = "delete from customers where id = ?";        Customer customer = new Customer();        customer.setId(4);        JDBCUtils.updateDomain(sql, customer);        sql = "update `order` set ordername = ? where orderid = ?";        Order order = new Order();        order.setOrderName("zzzz");        order.setOrderId(1);        JDBCUtils.updateDomain(sql, order);    }    @Test    public void testQueryDomain() {        String sql = "select id,name,email from customers where id < ?";        Customer customer = new Customer();        customer.setId(12);        List<Customer> list = JDBCUtils.queryDomain(Customer.class, sql, customer);        list.forEach(System.out::println);        String sql1 = "select orderid orderId,ordername orderName from `order`";        List<Order> orderList = JDBCUtils.queryDomain(Order.class, sql1, new Order());        orderList.forEach(System.out::println);    }    @Test    public void testUpdate() {//      String sql = "delete from customers where id = ?";//      update(sql,3);        String sql = "update `order` set ordername = ? where orderid = ?";        JDBCUtils.update(sql, "zys", "2");    }    @Test    public void testQuery() {        String sql = "select id,name,email from customers where id < ?";        List<Customer> list = JDBCUtils.query(Customer.class, sql, 12);        list.forEach(System.out::println);        String sql1 = "select orderid orderId,ordername orderName from `order`";        List<Order> orderList = JDBCUtils.query(Order.class, sql1);        orderList.forEach(System.out::println);    }}

总结：

1.0

增删改没有结果集，封装成一个方法，但是传的是具体的值，不是domain，公司框架传的是domain，那是如何获取值得呢？

查询操作因为需要返回不同的domainList，所以需要传入domain.class

2.0

新增updateDomain通过反射获取属性

3.0

新增queryDomain，完成告一段落

package com.apesblog.day_26;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class Test5 {    public static void main(String[] args) {        FileInputStream fileInputStream = null;        FileOutputStream fileOutputStream = null;        BufferedInputStream bufferInputStream = null;        BufferedOutputStream bufferedOutputStream = null;        try {            File file = new File("src/com/apesblog/day_26/1.png");            File file2 = new File(file.getParent(), "copy.png");            byte[] buffer = new byte[1024];            int len;            fileInputStream = new FileInputStream(file);            fileOutputStream = new FileOutputStream(file2);            bufferInputStream = new BufferedInputStream(fileInputStream);            bufferedOutputStream = new BufferedOutputStream(fileOutputStream);            while ((len = bufferInputStream.read(buffer)) != -1) {                bufferedOutputStream.write(buffer, 0, len);            }        } catch (IOException e) {            e.printStackTrace();        } finally {            try {                if (bufferInputStream != null)                    bufferInputStream.close();            } catch (IOException e) {                e.printStackTrace();            }            try {                if (bufferedOutputStream != null)                    bufferedOutputStream.close();            } catch (IOException e) {                e.printStackTrace();            }        }    }}