【自用】javaWeb复习笔记2，Servlet，JSP

Servlet

• servlet的生命周期
  init()初始化
  service()运行
  destroy()销毁

@WebServlet("/servlet01")
public class Servlet01 extends GenericServlet {
    @Override
    public void init() throws ServletException {
        System.out.println("init...");
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service...");
    }

    @Override
    public void destroy() {
        System.out.println("destroy...");
    }
}

• ServletConfig接口

@WebServlet(name = "/servlet02",initParams = {@WebInitParam(name = "encoding",value="UTF-8"),})
public class Servlet02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter out=resp.getWriter();
        ServletConfig config=this.getServletConfig();
        String parameter = config.getInitParameter("encoding");
        out.println("encoding:"+parameter);
    }
}

• ServletContext接口

作用一： 获取web程序的初始化参数

1. 在web.xml文件中配置

<context-param>
        <param-name>name</param-name>
        <param-value>ZhangSan</param-value>
    </context-param>
    <context-param>
        <param-name>address</param-name>
        <param-value>Beijing</param-value>
    </context-param>

2. 在servlet中循环获取参数名和值

@WebServlet("/servlet03")
public class Servlet03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter out = resp.getWriter();
        ServletContext context=this.getServletContext();
        Enumeration<String> parameterNames = context.getInitParameterNames();
        while (parameterNames.hasMoreElements()){
            String name = parameterNames.nextElement();
            String value = context.getInitParameter(name);
            out.println(name+":"+value);
        }
    }
}

作用二：实现多个对象共享数据
servlet04.java

@WebServlet("/servlet04")
public class Servlet04 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context=this.getServletContext();
        //通过setAttribute方法设置属性
        context.setAttribute("data","1234");
    }
}

servlet05.java

@WebServlet("/servlet05")
public class Servlet05 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter writer = resp.getWriter();
        ServletContext context=this.getServletContext();
        //通过getAttribute方法获取属性
        String data= (String)context.getAttribute("data");
        writer.println("data:"+data);
    }
}

作用三：读取Web应用下的资源文件

1. 新建.properties资源文件并写入

name=zhangsan
address=Beijing

2. 在Servlet文件中读取

@WebServlet("/servlet06")
public class Servlet06 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter writer = resp.getWriter();
        ServletContext context=this.getServletContext();
        InputStream inputStream = context.getResourceAsStream("data.properties");
        Properties properties = new Properties();
        properties.load(inputStream);
        String name = properties.getProperty("name");
        String address = properties.getProperty("address");
        writer.println("name:"+name+";"+"address:"+address);
    }
}

3. HttpServletResponse对象
   三个发送状态码的方法
   setStatus(int sc)：设置响应的状态码
   sendError(int sc)：发送错误状态码
   sendRedirect(String URL)：重定向到指定的URL地址

@WebServlet("/servlet07")
public class Servlet07 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        resp.setStatus(200);//设置成功时状态码
        resp.sendError(123,"error");//设置出错时响应的状态码
        resp.sendRedirect("www.baidu.com");//将HTTP响应重定向到指定的URL地址
    }
}

实现请求重定向
案例，登录
index.jsp，登录表单页面

<html>
  <head>
    <title>登录</title>
  </head>
  <body>
  <table>
 <form action="servlet08" method="get">
   <tr><td>用户名<td><input type="text" name="username" placeholder="请输入用户名" />
   <tr><td>密码<td><input type="password" name="password" placeholder="请输入密码" />
     <tr><td><td><input type="submit" name="提交" />
 </form>
  </table>
  </body>
</html>

success.html，登录成功跳转页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>success</title>
</head>
<body>
欢迎你，登录成功！
</body>
</html>

Servlet08.java

@WebServlet("/servlet08")
public class Servlet08 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        //获取表单提交的用户名密码
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        //检查用户名密码是否输入正确，以重定向到对应的页面
        if(username.equals("zhangsan")&&password.equals("1234")){
            resp.sendRedirect("success.html");
        }else{
            resp.sendRedirect("index.jsp");
        }
    }
}

HttpServletRequest对象
常用方法

1. getParameter(String name): 根据参数名获取对应的参数值，返回一个字符串类型的值。
2. getParameterValues(String name): 根据参数名获取对应的参数值，返回一个字符串数组。
3. getMethod(): 获取HTTP请求的方法，如GET、POST、PUT等。
4. getHeader(String name): 根据请求头的名称获取对应的请求头值，返回一个字符串类型的值。
5. getHeaderNames(): 获取所有请求头的名称，返回一个枚举类型的值。
6. getRequestURL(): 获取客户端发出请求的完整URL，不包括查询参数。
7. getRequestURI(): 获取客户端发出请求的URI，不包括主机名和端口号。
8. getRemoteAddr(): 获取客户端的IP地址。
9. getServletContext(): 获取ServletContext对象。
10. getSession(boolean create): 获取HttpSession对象，如果create参数为true，则在没有HttpSession对象时创建一个。

请求转发，地址栏URL不会变，转发路径path必须带 /

Servlet09.java

@WebServlet("/servlet09")
public class Servlet09 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        req.setAttribute("name","zhangsan");
        RequestDispatcher dispatcher = req.getRequestDispatcher("/servlet10");
        dispatcher.forward(req,resp);
    }
}

Servlet10.java

@WebServlet("/servlet10")
public class Servlet10 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      resp.setContentType("text/html;charset=utf-8");
        PrintWriter writer = resp.getWriter();
        String name = (String) req.getAttribute("name");
        writer.println("name:"+name);
    }
}

获取请求参数

请求重定向与请求转发总结

请求转发是在服务器内部进行页面跳转，跳转时保留了源请求的数据，在目标页面中可以访问到源页面传递过来的参数，常用于在同一个应用程序内进行页面跳转。

请求重定向是通过告诉浏览器要跳转到另一个页面，浏览器再次向指定的URL发送请求，常用于不同的应用程序之间进行页面跳转或者向客户端告知一个新的地址。在请求重定向中，源请求的数据会丢失，需要在重定向的URL中再次传递参数。

简单来说，如果是同一个应用程序内部的页面跳转，且需要传递参数，可以使用请求转发；如果是不同应用程序之间的页面跳转，或者需要告知一个新的地址，可以使用请求重定向。

请求参数

index.jsp

<html>
  <head>
    <title>登录</title>
  </head>
  <body>
  <table>
 <form action="/servlet11" method="get">
     <input type="hidden" name="charset" value="utf-8" />
   <tr><td>用户名<td><input type="text" name="username" placeholder="请输入用户名" />
     <tr><td>性别<td><input type="radio" name="sex" value="男">男<input type="radio" name="sex" value="女">女</tr>
     <tr><td>爱好<td><input type="checkbox" name="hobbies" value="dance">跳舞
         <input type="checkbox" name="hobbies" value="sing">唱歌
         <input type="checkbox" name="hobbies" value="swimming">游泳</tr>
     <tr><td><td><input type="submit" value="提交" />
 </form>
  </table>
  </body>
</html>

servlet11.java

@WebServlet("/servlet11")
public class Servlet11 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");//设置编码，在表单中文request获取输出不乱码，换行需要使用<br />
        PrintWriter writer = resp.getWriter();
        String username = req.getParameter("username");
        String sex = req.getParameter("sex");
        String[] hobbies = req.getParameterValues("hobbies");
        writer.println("username:"+username);
        writer.println("<br />sex:"+sex);
        writer.print("<br />hobbies:");
        for (String hobby : hobbies) {
            writer.print(hobby+" ");
        }
    }
}

Cookie
案例，获取用户上次登录时间

@WebServlet("/cookie02")
public class Cookie02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter writer = resp.getWriter();
        boolean flag=true;
        Cookie[] cookies = req.getCookies();
        for (Cookie cookie : cookies) {
            String name = cookie.getName();
            if("lastTime".equals(name)){
                writer.write("上次访问时间：");
                String value = cookie.getValue();
                long l = Long.parseLong(value);
                Date date = new Date(l);
                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
                String format = dateFormat.format(date);

                writer.write(format);
                flag=false;
            }
        }
        if(flag){
            writer.write("首次访问！");
        }
        Cookie cookie = new Cookie("lastTime", System.currentTimeMillis()+"");
        cookie.setMaxAge(600);
        resp.addCookie(cookie);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

Session
案例，实现购物车
Cake实体类

public class Cake {
    private String id;
    private String name;
    private double price;

    public Cake(String id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

模拟数据库，蛋糕库类

public class CakeDB {
    private static HashMap<String,Cake> cake= new HashMap<>();
    static {
        cake.put("1",new Cake("1","A",79.8));
        cake.put("2",new Cake("2","B",129.9));
        cake.put("3",new Cake("3","C",86.5));
        cake.put("4",new Cake("4","D",54.7));
    }
    public static Collection<Cake> getAll(){
        return cake.values();
    }
    public static Cake getCake(String id){
        return cake.get(id);
    }
}

购物页面，获取所有商品并输出Cart.java

@WebServlet("/cart")
public class Cart extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter writer = resp.getWriter();
        Collection<Cake> cakes = CakeDB.getAll();
        writer.println("商品名单");
        for (Cake cake : cakes) {
            writer.println(cake.getName()+"<a href='BuyServlet?id="+cake.getId()+"'>点击购买</a><br />");
        }
        writer.println("<a href='CartServlet'>查看购物车</a>");
    }
}

处理业务Servlet页面，当直接进入购物车页面没有传入id，则重定向回购物页面；当购物传入id，设置session属性cakes并通过获取的id找到对应cake将其添加进cakes。

@WebServlet("/BuyServlet")
public class BuyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        PrintWriter writer = response.getWriter();
        boolean flag=true;
        String id = request.getParameter("id");
        if(id==null){//直接访问，重定向到购物页面
            response.sendRedirect("Cart");
            return;
        }
        Cake cake = CakeDB.getCake(id);
        HttpSession session = request.getSession();
        List<Cake> cakes = (List<Cake>) session.getAttribute("cakes");
        if(cakes==null){
            cakes=new ArrayList<>();
            session.setAttribute("cakes",cakes);
            flag=false;
        }
        cakes.add(cake);

        //防止关闭浏览器后session id 消失，在设置时间内即使关闭浏览器下次打开还能访问到上次的数据
        Cookie cookie = new Cookie("JSESSIONID", session.getId());
        cookie.setMaxAge(600);//10分钟
        response.addCookie(cookie);

        response.sendRedirect("cart");
    }
}

购物车页面，CartServlet.java

@WebServlet("/CartServlet")
public class CartServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpSession session = request.getSession(false);
        PrintWriter writer = response.getWriter();
        List<Cake> cakes =null;
        boolean flag=true;
        if(session==null){
            flag=false;
        }else{
             cakes=(List<Cake>) session.getAttribute("cakes");
            if(cakes==null){
                flag=false;
            }
        }
        if(!flag){
            writer.println("购物车为空");
        }else{
            for (Cake cake : cakes) {
                writer.println(cake.getId()+","+cake.getName()+","+cake.getPrice());
            }
        }
    }
}

JSP

JSP（JavaServer Pages）是JavaWeb开发中一种动态网页技术，它的本质是将Java代码嵌入到HTML代码中，用于生成动态网页

1. JSP基本语法
   <% %>：用于嵌套Java代码，例如：<% System.out.println(“Hello, world!”); %>
   <%= %>：用于输出Java代码的值，例如：<%= “Hello, world!” %>
   <%@ %>：用于定义指令，例如：<%@ page language=“java” %>
   <%! %>：用于定义成员变量和方法，例如：<%! private String name = “Tom”; %>

<% java 代码（变量、方法、表达式等）%>

<%= JSP表达式 %>

<%! 定义变量或方法等 %>

<%--注释 --%>

2. JSP 内置对象
   JSP 中有 9 个内置对象，分别是 request、response、session、application、out、pageContext、config、page、exception，可以在 JSP 页面中直接使用。
   
   request：用于获取客户端请求信息。
   response：用于向客户端发送响应信息。
   session：用于在不同的请求之间存储和共享数据。
   application：用于在整个应用程序中存储和共享数据。
   out：用于向客户端输出响应信息。
   pageContext：用于获取页面上下文信息。

3. EL 表达式
   可以在 JSP 页面中轻松地访问 JavaBean 中的属性或调用 JavaBean 中的方法，简化了页面上的数据操作。
   ${}：用于获取页面数据，例如：${requestScope.name}
   ${}：用于设置页面数据，例如：${sessionScope.name=“Tom”}

4. JSP中的标签库
   JSTL标签库：包括核心标签库和格式化标签库。

5. JSP 中的注释
   JSP 中有三种注释方式，分别是 HTML 注释、JSP 注释、Java 注释，可以在不同的场景下使用

<!-- 这是HTML注释 -->
<%-- 这是JSP注释 --%>
//java单行注释
/*java多行注释*/

6. JSP 页面传参
   可以通过 URL 传参、表单提交、隐藏域等方式传参，通过 request 对象获取传参的值。

• URL传参

<a href="user.jsp?id=123">用户详情</a>

在user.jsp页面中，可以通过request.getParameter()方法获取传递的参数

<%
    String id = request.getParameter("id");
%>

• 通过表单POST方法提交参数

<form method="post" action="login.jsp">
    <input type="text" name="username" />
    <input type="password" name="password" />
    <input type="submit" value="提交" />
</form>

在login.jsp页面中，可以通过request.getParameter()方法获取提交的参数

<%
    String username = request.getParameter("username");
    String password = request.getParameter("password");
%>

• 通过Session传递参数
  在一个JSP页面中将数据存储到Session中

<%
    session.setAttribute("username", "张三");
%>

在另一个JSP页面中获取Session中存储的数据

<%
    HttpSession session = request.getSession();
    String username = (String)session.getAttribute("username");
%>

7. JSP 页面跳转
   页面跳转可以通过请求转发和重定向实现。请求转发是服务器直接将请求转发到另一个页面，客户端并不知道，而重定向是客户端发送新的请求到新的 URL 上。

• 重定向
  重定向是指在服务器端向浏览器发送一个指令，告诉浏览器重新发送一个新的请求，新的请求地址是由服务器返回的，浏览器将会跳转到这个新的地址。重定向的特点是地址栏会变化，浏览器会发送两次请求。

<%
    response.sendRedirect("http://www.baidu.com");
%>

• 请求转发
  转发是指在服务器端将请求转发到另一个JSP页面或Servlet中处理，转发后浏览器地址栏不会发生变化，只发送一次请求，效率比重定向高。

方式一：使用 request 对象的 forward 方法

<%
    request.getRequestDispatcher("/other.jsp").forward(request,response);
%>

方式二：使用 JSP 的 jsp:forward 标签

<jsp:forward page="/example.jsp" />

总结：重定向和转发都可以实现页面跳转，但实现方式和效果不同，应根据需要选择。如果要跳转到另一个web应用的页面，只能使用重定向。如果要跳转到当前web应用的其他页面，建议使用转发。

8. JSP中包含include页面的两种方式
   方式一：使用<%@ include file=“include.jsp” %>指令
   静态的，将运行结果包含
   方式二：使用<jsp:include page=“include.jsp” />标签
   动态的，运行时包含，将代码引进
   两种方式的区别在于，静态包含是在编译时完成的，因此效率高，但无法动态修改被包含的文件内容；动态包含是在运行时完成的，因此可以动态修改被包含的文件内容，但效率相对较低。

JavaBean的使用
JavaBean 是 JSP 中常用的一种数据封装方式，它可以有效地将数据和业务逻辑与展示代码分离，使得 JSP 的编写更加简单易读。

使用<jsp:setProperty property=“*”/>接收所有参数

<%--使用<jsp:useBean>标签创建JavaBean的实例对象
使用 <jsp:setProperty> 标签将页面提交的数据设置到 JavaBean 的属性中；
使用 <jsp:getProperty> 标签获取 JavaBean 对象的属性值，并将其展示在页面上。
--%>
<jsp:useBean id="person" class="com.example.demo.Person" />
<jsp:setProperty name="person" property="name" value="zhangsan" />
<jsp:setProperty name="person" property="age" value="13" />
<jsp:setProperty name="person" property="gender" value="male" />

<p>用户名：<jsp:getProperty name="person" property="name" /></p>
<p>年龄：<jsp:getProperty name="person" property="age" /></p>
<p>性别：<jsp:getProperty name="person" property="gender" /></p>

<%--使用EL表达式获取bean中的信息--%>
<h1>个人信息</h1>
<p>姓名：${person.name}</p>
<p>年龄：${person.age}</p>
<p>性别：${person.gender}</p>

JSP的两种开发模型

• JSP Model1采用JSP+JavaBean的技术
• JSP Model2架构模型采用JSP+Servlet+ JavaBean的技术，Model2模型就是MVC（Model-View-Controller，模型-视图-控制器）设计模式，其中控制器的角色由Servlet实现，视图的角色由JSP页面实现，模型的角色是由JavaBean的实现。
  三个核心模块：模型（Model）、视图（View）和控制器（Controller）

JDBC

注：在项目中使用 JDBC 连接数据库，需要在项目中引入 JDBC 驱动包，可以将驱动包放在项目的 lib 目录中，或者使用 Maven 等构建工具引入依赖。 在 Maven 项目中使用 JDBC 连接数据库，需要在 pom.xml 文件中添加相关的 JDBC 驱动依赖。以下是 MySQL 数据库的 Maven 依赖示例

<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.15</version>
</dependency>

1. 数据库连接的四步

第一步： 加载并注册数据库驱动程序
通过Class.forName()方法加载相应的JDBC驱动程序。

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

使用DriverManager.registerDriver()方法注册驱动类

DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());

第二步：建立数据库连接
使用DriverManager.getConnection()方法创建一个连接对象，该方法需要传入数据库连接URL、用户名和密码等信息。

String url = "jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC";
String user = "root";
String password = "123456";
Connection conn = DriverManager.getConnection(url, user, password);

第三步：创建语句对象
使用Connection对象的createStatement()方法或prepareStatement()方法创建一个Statement对象或PreparedStatement对象，用于执行SQL语句。

Statement stmt = conn.createStatement();

第四步：执行SQL语句并处理结果
使用Statement对象或PreparedStatement对象的executeQuery()方法执行查询语句，或者使用executeUpdate()方法执行更新语句等。

ResultSet rs = stmt.executeQuery("select * from user");
while(rs.next()){
    System.out.println(rs.getString("name"));
}

具体代码示例

Users.java

public class Users {
    private int id;
    private String username;
    private String password;

    public Users() {
    }

    public Users(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "Users{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

GetConnection.java

public class GetConnection {
    Connection conn=null;
    public Connection getConnection() throws ClassNotFoundException{
        try {
            //注册驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            //获取连接,&useUnicode=true&characterEncoding=utf-8
            String url="jdbc:mysql://localhost:3306/jdbc?useSSL=false&&serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8";
            String user="root";
            String password="0987";
            conn=(Connection) DriverManager.getConnection(url,user,password);
        }catch (SQLException e){
            e.printStackTrace();
        }
        return conn;
    }
}

ConnectionJDBC.java

public class ConnectionJDBC {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 查询所有的User对象
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        // 获得数据的连接
        conn = new GetConnection().getConnection();
        // 获得Statement对象
        stmt = conn.createStatement();
        // 发送SQL语句
        String sql = "SELECT * FROM users";
        rs = stmt.executeQuery(sql);
        // 处理结果集
        while (rs.next()) {
            Users user=new Users();
            user.setId(rs.getInt("id"));
            user.setUsername(rs.getString("username"));
            user.setPassword(rs.getString("password"));
            System.out.println(user.toString());
        }
    }

}

PreparedStatement对象
Statement提供了一个子类PreparedStatement
PreparedStatement使用预编译的SQL语句，可以提高SQL的执行效率

public class ConnectionJDBC {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 查询所有的User对象
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        // 获得数据的连接
        conn = new GetConnection().getConnection();
        // 预编译SQL语句
        String sql = "SELECT * FROM users WHERE username = ?";
        pstmt = conn.prepareStatement(sql);
        // 设置查询参数
        pstmt.setString(1, "小新");
        // 执行查询操作
        rs = pstmt.executeQuery();

        // 处理结果集
        while (rs.next()) {
            Users user=new Users();
            user.setId(rs.getInt("id"));
            user.setUsername(rs.getString("username"));
            user.setPassword(rs.getString("password"));
            System.out.println(user.toString());
        }
    }
}

ResultSet对象
ResultSet主要用于存储结果集，可以通过next()方法由前向后逐个获取结果集中的数据