JDBC调用存储过程和函数

拼搏现实的明天。 2022-04-02 06:29 293阅读 0赞

# [JDBC调用存储过程和函数][JDBC] #

在数据库中我们可以写一些存储过程和函数，来封装一些常用的SQL语句，存储过程和函数目的是为了可重复地执行操作数据库的sql语句的集合

返回值上：

*  存储过程的返回值，可以有多个值
 *  函数的返回值，只有一个值

函数是可以嵌入在SQL中使用的，可以在SELECT等SQL语句中调用，而存储过程则不行。我们可以在数据库中创建一些常用的存储过程和函数，这样我们在数据访问层直接调用即可。这里记录一下使用JDBC调用存储过程和函数的方法

# 调用没有返回值的存储过程 #

首先我们在数据库中创建一个没有返回值的存储过程：

create or replace procedure proc_Ins_Dept(vid in varchar2 ,vname  in varchar2,vloc in varchar2) is
    begin insert into Dept values(vid,vname,vloc);
    end proc_Ins_Dept;

我是在Oracle中创建的，其他的数据库大同小异

在Dao中调用：

![复制代码][20181225164953447]

// 无返回值的存储过程
        public void proc1() {
            try {
    
                Connection conn = super.getConn();    //调用了BaseDao创建连接
    
                CallableStatement cs = conn.prepareCall("{call proc_Ins_Dept(?,?,?)}");  //调用格式 {call 存储过程名(参数)}
                cs.setObject(1, 76);
                cs.setObject(2, "技术部");
                cs.setObject(3, "zhengzhou");
                cs.execute();            //执行
                cs.close();
                conn.close();
    
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    
        }

![复制代码][20181225164953447]

# 调用有返回值的存储过程 #

创建有返回值的存储过程：

![复制代码][20181225164953447]

create or replace procedure pro_Ins_Dept (vid in varchar2,vname in varchar2,vloc in varchar2,vresult out varchar2) is 
    begin insert into Dept values(vid,vname,vloc);
      vresult:='success';
    Exception
      when others then
       vresult:='fail';
    end pro_Ins_Dept;

![复制代码][20181225164953447]

输入值使用in，返回值使用out表示

在Dao中调用：

![复制代码][20181225164953447]

// 带返回值的存储过程
        public void proc2() {
            try {
                Connection conn = super.getConn();
                CallableStatement cs = conn.prepareCall("{call proc_Ins_Dept2(?,?,?,?)}");
                cs.setObject(1, 76);
                cs.setObject(2, "市场部");
                cs.setObject(3, "luoyang");
                cs.registerOutParameter(4, java.sql.Types.VARCHAR);           //注册返回类型(sql类型)
                cs.execute();
    
                Object objRtn = cs.getObject(4);      //得到返回值
    
                System.out.println(objRtn);
    
                cs.close();
                conn.close();
    
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    
        }

![复制代码][20181225164953447]

唯一不同的是我们需要给返回值注册类型，可以在java.sql.Types类中找到对应的Sql类型，Oracle中的varchar2对应的也是varchar。最后使用CallableStatement的get方法得到返回结果

# 调用自定义函数 #

SQL语句：

create or replace function fun_avg_dept(vdeptno in number)
        return number is 
           r number;
    begin select avg(sal) into r from emp where deptno=vdeptno;
           return(r);
    end fun_avg_dept;

Dao中调用：

![复制代码][20181225164953447]

// 带返回值的自定义函数
        public void fun1() {
            try {
                Connection conn = super.getConn();
                               
                //函数可以嵌入到Sql中
                String sql = "select fun_avg_dept(?) from dual";
    
                //调用方式还是和使用ps调用普通SQL一样
                PreparedStatement ps = conn.prepareStatement(sql);
    
                ps.setObject(1, 10);
    
                ResultSet rs = ps.executeQuery();
    
                if (rs.next()) {
                    System.out.println(rs.getObject(1));
                }
    
                rs.close();
                ps.close();
                conn.close();
    
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    
        }

![复制代码][20181225164953447]

标签: [JavaEE笔记][JavaEE]

[https://www.cnblogs.com/lz2017/p/7500411.html][JDBC]

*  [博客园][Link 1]
 *  [首页][Link 2]
 *  [新随笔][Link 3]
 *  [联系][Link 4]
 *  [管理][Link 5]
 *  [订阅][Link 6][![订阅][20181225164953584]][Link 6]

随笔- 51  文章- 1  评论- 0

# [如何使用 JDBC 调用存储在数据库中的函数或存储过程][JDBC 1] #

JDBC调用存储过程  
步骤：  
1 通过Connection对象的prepareCall()方法创建一个CallableStatement对象的实例。在使用Connection对象的prepareCall()方法时，需要传入一个String类型的字符串，该字符串用于指明如何调用存储过程  
\{?= call <procedure-name>\[(<arg1>,<arg2>, ...)\]\}  
\{call <procedure-name>\[(<arg1>,<arg2>, ...)\]\}

2 通过CallableStatement对象的registerOutParameter()方法注册OUT参数  
3 通过CallableStatement对象的setXxx()方法设定IN或IN OUT参数  
若想将参数默认值设为Null,可以使用setNull()方法  
4 通过CallableStatement对象的execute()方法执行存储过程  
5 如果所调用的是带返回参数的存储过程，还需要通过CallableStatement对象的getXxx()方法获取其返回值  
注：通过数据字典查看存储过程或函数的定义

select text from user\_source where lower(name)='add\_fun';  
调用函数：

package com.atguigu.jdbc;

import static org.junit.Assert.\*;

import java.sql.CallableStatement;  
import java.sql.Connection;  
import java.sql.SQLException;  
import java.sql.Types;

import javax.sql.DataSource;

import org.junit.Test;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class JDBCTest \{

/\*\*  
\* 如何使用 JDBC 调用存储在数据库中的函数或存储过程  
\*/  
@Test  
public void testCallableStatment() \{

Connection connection = null;  
CallableStatement callableStatement = null;

try \{  
connection = JDBCTools.getConnection();

// 1. 通过 Connection 对象的 prepareCall()  
// 方法创建一个 CallableStatement 对象的实例.  
// 在使用 Connection 对象的 preparedCall() 方法时,  
// 需要传入一个 String 类型的字符串, 该字符串用于指明如何调用存储过程.  
String sql = "\{?= call sum\_salary(?, ?)\}";  
callableStatement = connection.prepareCall(sql);

// 2. 通过 CallableStatement 对象的   
//reisterOutParameter() 方法注册 OUT 参数.  
callableStatement.registerOutParameter(1, Types.NUMERIC);  
callableStatement.registerOutParameter(3, Types.NUMERIC);  
  
// 3. 通过 CallableStatement 对象的 setXxx() 方法设定 IN 或 IN OUT 参数. 若想将参数默认值设为  
// null, 可以使用 setNull() 方法.  
callableStatement.setInt(2, 80);  
  
// 4. 通过 CallableStatement 对象的 execute() 方法执行存储过程  
callableStatement.execute();  
  
// 5. 如果所调用的是带返回参数的存储过程,   
//还需要通过 CallableStatement 对象的 getXxx() 方法获取其返回值.  
double sumSalary = callableStatement.getDouble(1);  
long empCount = callableStatement.getLong(3);  
  
System.out.println(sumSalary);  
System.out.println(empCount);  
  
\} catch (Exception e) \{  
e.printStackTrace();  
\} finally \{  
JDBCTools.releaseDB(null, callableStatement, connection);  
\}

@Test  
public void testC3P0() throws SQLException \{  
DataSource dataSource = new ComboPooledDataSource("c3p0");

System.out.println(dataSource.getConnection());  
\}

标签: [JDBC][JDBC 2]

好文要顶 关注我 收藏该文 ![20181225164953605][] ![20181225164953620][]

[![20181225164953637][]][20181225164953637 1]

[苍狼哂啡][20181225164953637 1]  
[关注 - 3][- 3]  
[粉丝 - 1][- 1]

\+加关注

[« ][Link 7]上一篇：[c3p0数据库连接池使用--创建JDBCTools 公共类][Link 7]  
[» ][Link 8]下一篇：[如何使用JDBC调用存储在数据库中的函数或存储过程 \*/][Link 8]

[https://www.cnblogs.com/xiaona19841010/p/5223779.html][JDBC 1]

# [JDBC学习笔记(10)——调用函数&存储过程][JDBC_10] #

如何使用JDBC调用存储在数据库中的函数或存储过程：

\* 1.通过COnnection对象的prepareCall()方法创建一个CallableStatement  
\*    对象的实例,在使用Connection对象的prepareCall() 方法时，需要传入一个String类型的字符串，  
\*    该字符串用于指明如何调用存储过程

\* 2.通过CallableStatement对象的registerOutParameter() 方法注册Out参数

\* 3.通过CallableStatement对象的setXxx()方法设定IN或In out  
\*    参数，若想将参数设为null，可以使用setNUll()

\* 4.通过CallableStatement对象的execute()方法执行存储过程

\* 5.如果所调用的是带返回参数的存储过程没还需要通过CallableStatement对象的getXxx()函数进行获取

具体的代码实现：

![复制代码][20181225164953447]

1     @Test
     2     public void testCallableStatement() {
     3         Connection connection = null;
     4         /**
     5          * 调用存储函数 1.{?= call <procedure-name>[(<arg1>,<arg2>, ...)]} 
     6          * 调用存储过程 2.{call <procedure-name>[(<arg1>,<arg2>, ...)]}
     7          */
     8         // 调用存储函数和调用存储过程，一个sql语句的区别
     9         String sql = "{?= call <procedure-name>[(<arg1>,<arg2>, ...)]}";
    10         CallableStatement callableStatement = null;
    11         try {
    12 
    13             connection = JDBCTools.getConnection();
    14             /*
    15              * 1.通过COnnection对象的prepareCall()方法创建一个CallableStatement
    16              * 对象的实例,在使用Connection对象的prepareCall() 方法时，需要传入一个String类型的字符串，
    17              * 该字符串用于指明如何调用存储过程
    18              */
    19             callableStatement = connection.prepareCall(sql);
    20 
    21             /*
    22              * 2.通过CallableStatement对象的registerOutParameter() 方法注册Out参数
    23              */
    24             callableStatement.registerOutParameter(1, Types.NUMERIC);
    25             callableStatement.registerOutParameter(3, Types.NUMERIC);
    26 
    27             /*
    28              * 3.通过CallableStatement对象的setXxx()方法设定IN或In out
    29              * 参数，若想将参数设为null，可以使用setNUll()
    30              */
    31             callableStatement.setInt(2, 80);
    32 
    33             /* 4.通过CallableStatement对象的execute()方法执行存储过程 */
    34             callableStatement.execute();
    35 
    36             /*
    37              * 5.如果所调用的是带返回参数的存储过程没还需要通过CallableStatement对象的getXxx()
    38              */
    39             double sumSalary = callableStatement.getDouble(1);
    40             long empCount = callableStatement.getLong(3);
    41         } catch (Exception e) {
    42             e.printStackTrace();
    43         } finally {
    44             JDBCTools.release(null, callableStatement, connection);
    45         }
    46     }

![复制代码][20181225164953447]

调用函数和存储过程的sql语句的区别：

**\* 调用存储函数 1.\{?= call <procedure-name>\[(<arg1>,<arg2>, ...)\]\} **  
**\* 调用存储过程 2.\{call <procedure-name>\[(<arg1>,<arg2>, ...)\]\}**

这个知识点暂时没用到，先做下笔记，待以后用到以后再深入研究，JDBC的学习暂时告一段落，开启新的学习征程！

--------------------

**个人感悟：把简单的事情做到极致,打扎实的基础,写优秀的代码**

本文为博主原创文章，转载请注明出处：[http://www.cnblogs.com/ysw-go/][http_www.cnblogs.com_ysw-go]  
1、本博客的原创原创文章，都是本人平时学习所做的笔记，如有错误，欢迎指正。  
2、如有侵犯您的知识产权和版权问题，请通知本人，本人会即时做出处理文章。  
3、本博客的目的是知识交流所用，转载自其它博客或网站，作为自己的参考资料的，感谢这些文章的原创人员

分类: [JDBC][JDBC 3]

好文要顶 关注我 收藏该文 ![20181225164953605][] ![20181225164953620][]

[![20181225164953717][]][20181225164953717 1]

[菜鸟奋斗史][20181225164953717 1]  
[关注 - 23][- 23]  
[粉丝 - 131][- 131]

\+加关注

[« ][Link 9]上一篇：[JDBC学习笔记(9)——DBUtils的使用][Link 9]  
[» ][Link 10]下一篇：[HTML+CSS+JS学习总结][Link 10]

[https://www.cnblogs.com/ysw-go/p/5480675.html][JDBC_10]

# java实现存储过程并同时得到out与return的值 #

置顶 2017年07月09日 15:12:40 [风雪夜归人提示已存在][Link 11] 阅读数：637 标签： [java][][存储过程][Link 12][数据库][Link 13]

@Test  
public final void test() \{  
SessionFactory sf = baseDao4.getSessionFactory();//任意穿件一个session  
Session session = sf.openSession();  
try\{  
       //session.beginTransaction(); //如果有spring来管理事务,记得注销这句  
        session.doWork(  
        new Work() \{  
@Override  
public void execute(Connection connection) throws SQLException \{  
CallableStatement cs = connection.prepareCall("\{?=CALL GSP\_GR\_DISTRIBUTOR(?,?,?,?,?,?)\}"); //第一个?是return的值  //最后一个是out的值. jdbc下标从1开始.hibernate是从0开始.坑爹了.  
cs.registerOutParameter(1,java.sql.Types.INTEGER);  
                   cs.setInt(2, 999999);  
                   cs.setInt(3, 1);      
                   cs.setInt(4, 1);      
                   cs.setInt(5, 1);      
                   cs.setInt(6, 1);    
                   cs.registerOutParameter(7,java.sql.Types.NVARCHAR);  
                   cs.execute();  
                   int a = cs.getInt(1);  
                   System.out.println(a);  
                   String result = cs.getString(7);  
        System.out.println(result);  
/\*  
\* 可用  
Statement s = connection.createStatement();  
String sql = "select \* from RechargeRecord";  
    ResultSet rs = s.executeQuery(sql);  
      
    while(rs.next())\{  
    System.out.println(rs.getInt(1));  
    \}\*/  
\}  
\}   
        );  
     //    session.getTransaction().commit();  
         
   \}catch(Exception e)\{  
      e.printStackTrace();  
   \}  
   finally\{  
      session.close();  //如果用spring管理,也需要这就关闭连接.  
   \}  
  
\}

[https://blog.csdn.net/qq\_38024577/article/details/74887053][https_blog.csdn.net_qq_38024577_article_details_74887053]

[狐小仙][Link 14]

## [JDBC操作存储过程、存储函数、out参数使用游标][JDBC_out] ##

## JDBC工具类 ##

![复制代码][20181225173054606]

public class JDBCUtils {
        private static String driver = "oracle.jdbc.OracleDriver";
        private static String url = "jdbc:oracle:thin:@192.168.79.128:1521/orcl";
        private static String user = "scott";
        private static String password = "tiger";
        
        
        static{
            //注册驱动
            //DriverManager.registerDriver(driver)
            try {
                Class.forName(driver);
            } catch (ClassNotFoundException e) {
                throw new ExceptionInInitializerError(e);
            }
        }
        
        public static Connection getConnection(){
            try {
                return DriverManager.getConnection(url, user, password);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
        
        public static void release(Connection conn,Statement st,ResultSet rs){
            if(rs != null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    rs = null; ///-----> 原因：Java GC: Java的GC不受代码的控制
                }
            }
            if(st != null){
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    st = null;
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    conn = null;
                }
            }
        }
    }

![复制代码][20181225173054606]

## 存储过程 ##

![复制代码][20181225173054606]

--存储过程
    create or replace procedure queryEmpInformation(eno in number,
                                                    pename out varchar2,
                                                    psal out number,
                                                    pjob out varchar2)
    is
    begin
      select ename,sal,job into pename,psal,pjob from emp where empno = eno;
    end queryEmpInformation;

![复制代码][20181225173054606]

### java代码 ###

![复制代码][20181225173054606]

@Test
        public void testProcedure(){
            //jdbc调用存储过程sql语句:
            //{call <procedure-name>[(<arg1>,<arg2>, ...)]}
            String sql = "{call queryEmpInformation(?,?,?,?)}";
            
            Connection conn = null;
            CallableStatement call = null;
            
            try{
                conn = JDBCUtils.getConnection();
                call = conn.prepareCall(sql);
                
                //输入参数赋值
                call.setInt(1, 7839);
                
                //输出参数，声明为输出参数
                call.registerOutParameter(2, OracleTypes.VARCHAR);
                call.registerOutParameter(3, OracleTypes.NUMBER);
                call.registerOutParameter(4, OracleTypes.VARCHAR);
                
                //执行
                call.execute();
                
                //获取值
                String name = call.getString(2);
                double sal = call.getDouble(3);
                String job = call.getString(4);
                System.out.println(name+"\t"+sal+"\t"+job);
            }catch (Exception e){
                e.printStackTrace();
            }finally{
                JDBCUtils.release(conn, call, null);
            }
        }

![复制代码][20181225173054606]

## 存储函数 ##

![复制代码][20181225173054606]

--存储函数
    create or replace function queryEmpIncome(eno in number)
    return number
    is
    psal emp.sal%type;
    pcomm emp.comm%type;
    begin
      select sal,comm into psal,pcomm from emp where empno = eno;
      return psal*12+nvl(pcomm,0);
    end queryEmpIncome;

![复制代码][20181225173054606]

### java代码 ###

![复制代码][20181225173054606]

@Test
        public void testFuntion(){
            //jdbc调用存储函数sql语句：
            //{?= call <procedure-name>[(<arg1>,<arg2>, ...)]}
            String sql = "{? = call queryEmpIncome(?)}";
            
            Connection conn = null;
            CallableStatement call = null;
            
            try{
                conn = JDBCUtils.getConnection();
                call = conn.prepareCall(sql);
                
                //注册输出参数
                call.registerOutParameter(1, OracleTypes.NUMBER);
                //输入参数
                call.setInt(2, 7839);
                
                //执行
                call.execute();
                
                //取出返回值
                double income = call.getDouble(1);
                System.out.println("年薪："+income);
            }catch (Exception e){
                e.printStackTrace();
            }finally{
                JDBCUtils.release(conn, call, null);
            }
        }

![复制代码][20181225173054606]

## out参数游标 ##

![复制代码][20181225173054606]

--创建包头
    create or replace package mypackage 
    is
    --定义一个cursor类型变量
    type empcursor is ref cursor;
    procedure queryEmpList(dno in number,empList out empcursor);
    end mypackage;
    
    
    --创建包体
    create or replace package body mypackage is
      procedure queryEmpList(dno in number,empList out empcursor)
        as
        begin
          open empList for select * from emp where deptno = dno;
          end;
    end mypackage;

![复制代码][20181225173054606]

### java代码 ###

![复制代码][20181225173054606]

@Test
        public void testCursor(){
            String sql = "call mypackage.queryEmpList(?,?)";
            
            Connection conn = null;
            CallableStatement call = null;
            ResultSet rs = null;
            
            try{
                conn = JDBCUtils.getConnection();
                call = conn.prepareCall(sql);
                
                call.setInt(1, 20);
                call.registerOutParameter(2, OracleTypes.CURSOR);
                
                call.execute();
                
                rs = ((OracleCallableStatement)call).getCursor(2);
                while(rs.next()){
                    String name = rs.getString("ename");
                    double sal = rs.getDouble("sal");
                    System.out.println(name+"\t"+sal);
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally{
                JDBCUtils.release(conn, call, null);
            }
        }

![复制代码][20181225173054606]

分类: [Java][]

好文要顶 关注我 收藏该文 ![20181225173054731][] ![20181225173054748][]

[![2018122517305568][]][2018122517305568 1]

[狐小仙][2018122517305568 1]  
[关注 - 0][- 0]  
[粉丝 - 0][- 0 1]

\+加关注

[« ][Link 15]上一篇：[存储过程函数][Link 15]  
[» ][Link 16]下一篇：[触发器][Link 16]

posted on 2018-08-01 17:22 [狐小仙][Link 14] 阅读(184) 评论(0) [编辑][Link 17] [收藏][Link 18]

[https://www.cnblogs.com/zsh-wj/p/9402486.html][JDBC_out]

[JDBC]: https://www.cnblogs.com/lz2017/p/7500411.html
[20181225164953447]: /images/20220402/9baf55da9e8d4c3486ca1f37ee880634.png
[JavaEE]: https://www.cnblogs.com/lz2017/tag/JavaEE%E7%AC%94%E8%AE%B0/
[Link 1]: https://www.cnblogs.com/
[Link 2]: https://www.cnblogs.com/xiaona19841010/
[Link 3]: https://i.cnblogs.com/EditPosts.aspx?opt=1
[Link 4]: https://msg.cnblogs.com/send/%E8%8B%8D%E7%8B%BC%E5%93%82%E5%95%A1
[Link 5]: https://i.cnblogs.com/
[Link 6]: /images/20220402/262a2c58250741559d28b67a44d56faf.png
[20181225164953584]: https://img-blog.csdnimg.cn/20181225164953584
[JDBC 1]: https://www.cnblogs.com/xiaona19841010/p/5223779.html
[JDBC 2]: https://www.cnblogs.com/xiaona19841010/tag/JDBC/
[20181225164953605]: https://img-blog.csdnimg.cn/20181225164953605
[20181225164953620]: /images/20220402/869ca2be01e14f0b9756302cf6ddeb96.png
[20181225164953637]: /images/20220402/b6947fca359f46da98f9eceab1b4e245.png
[20181225164953637 1]: http://home.cnblogs.com/u/xiaona19841010/
[- 3]: http://home.cnblogs.com/u/xiaona19841010/followees
[- 1]: http://home.cnblogs.com/u/xiaona19841010/followers
[Link 7]: https://www.cnblogs.com/xiaona19841010/p/5205474.html
[Link 8]: https://www.cnblogs.com/xiaona19841010/p/5226181.html
[JDBC_10]: https://www.cnblogs.com/ysw-go/p/5480675.html
[http_www.cnblogs.com_ysw-go]: http://www.cnblogs.com/ysw-go/
[JDBC 3]: https://www.cnblogs.com/ysw-go/category/823430.html
[20181225164953717]: /images/20220402/319634b97ea343f3866be88fff26bdb1.png
[20181225164953717 1]: http://home.cnblogs.com/u/ysw-go/
[- 23]: http://home.cnblogs.com/u/ysw-go/followees
[- 131]: http://home.cnblogs.com/u/ysw-go/followers
[Link 9]: https://www.cnblogs.com/ysw-go/p/5478503.html
[Link 10]: https://www.cnblogs.com/ysw-go/p/5491990.html
[Link 11]: https://me.csdn.net/qq_38024577
[java]: http://so.csdn.net/so/search/s.do?q=java&t=blog
[Link 12]: http://so.csdn.net/so/search/s.do?q=%E5%AD%98%E5%82%A8%E8%BF%87%E7%A8%8B&t=blog
[Link 13]: http://so.csdn.net/so/search/s.do?q=%E6%95%B0%E6%8D%AE%E5%BA%93&t=blog
[https_blog.csdn.net_qq_38024577_article_details_74887053]: https://blog.csdn.net/qq_38024577/article/details/74887053
[Link 14]: https://www.cnblogs.com/zsh-wj/
[JDBC_out]: https://www.cnblogs.com/zsh-wj/p/9402486.html
[20181225173054606]: /images/20220402/e285c08cf66e44598a026a64cf4b786c.png
[Java]: https://www.cnblogs.com/zsh-wj/category/1149058.html
[20181225173054731]: https://img-blog.csdnimg.cn/20181225173054731
[20181225173054748]: /images/20220402/c034eca00cf4484bb074411cdcff3173.png
[2018122517305568]: /images/20220402/f62008237d6b4fb6a0ca0b937df5bbdc.png
[2018122517305568 1]: http://home.cnblogs.com/u/zsh-wj/
[- 0]: http://home.cnblogs.com/u/zsh-wj/followees
[- 0 1]: http://home.cnblogs.com/u/zsh-wj/followers
[Link 15]: https://www.cnblogs.com/zsh-wj/p/9400199.html
[Link 16]: https://www.cnblogs.com/zsh-wj/p/9406342.html
[Link 17]: https://i.cnblogs.com/EditPosts.aspx?postid=9402486
[Link 18]: https://www.cnblogs.com/zsh-wj/p/9402486.html#