Servlet变量范围使用指南以及数据库连接
2011-09-20 14:55
225 查看
Servlet变量范围使用指南
1. 在Java语言中，有类变量、实例变量、方法变量和代码块变量，每种变量都有自己的作用域和生命周期。
public class VariableScopeDemo {
/*1、类变量，生命周期：从该类被虚拟机加载直到到该类被卸载，该变量都存在；
* 作用域：可以被该类的所有实例访问*/
private static double PI=3.1415926;
/*2、实例变量，生命周期：从该类的一个实例创建到被垃圾回收，该变量存在；
* 作用域：可以被该实例的所有方法中使用
* **/
private double radius;
public double square(){
/*
* 3、方法变量，生命周期：从该被调用，运行到变量的声明处到该方法返回，该变量都存在
* 作用域：变量的声明到方法结束前都可以访问
* */
double square=PI*radius*radius;//square声明周期开始
/**
*4、 代码块，其中K是代码块变量，生命周期：从代码块中声明该变量开始到代码块结束
* 作用域：从代码块中声明该变量开始到代码块结束
* */
{
int k=0;//k生命周期开始
k++;
}//k生命周期结束
return square;
}//square声明周期结束
public double zhouchang(){
double zhouchang=2*PI*radius;
return zhouchang;
}
public void setRadius(double radius) {
this.radius = radius;
}
}
2、为什么要有这么多变量类型？我们知道程序运行时间变量都会被分配内存。比如方法变量，在方法调用结束后，我们就不需要该变量了，这时间就可以释放它占用的内存。由于内存不是无限的，在一个变量不需要使用的时候，我们就要及时释放它占用的内存，以免内存被耗尽。
3、Java中不定参数的传递方法。
3.1 同种类型变量传递，比如我们常见的主方法。可以接收不定个数的字符串参数
public static void main(String[] args) {
}
3.2 异种类型变量传递。方法是参数是一个Map，这样我们就可以传递不定参数进去。
import java.util.HashMap;
import java.util.Map;
//该对象用户封装请求请求参数，模拟HttpRequest对象
public class Request {
Map<String, Object> parameter=new HashMap<String, Object>();
public void setAttibute(String name,Object value){
parameter.put(name, value);
}
public Object getAttibute(String name){
return parameter.get(name);
}
}
//该方法用于模拟我们怎么创建在一个方法中设置对象，并把它作为参数传递给//另外一个函数
public class VariableParameterDemo {
public static void test(Request request){
Integer age=(Integer) request.getAttibute("age");
String name=(String) request.getAttibute("name");
System.out.println("age="+age+";name="+name);
}
public static void main(String[] args) {
Request mapP=new Request();
mapP.setAttibute("age", new Integer(20));
mapP.setAttibute("name", "zhangsan");
//我们通过Request对象把不定参数的对象传递给了test方法。
test(mapP);
}
}
4、Servlet对象之间对象传递。
4.1在Servlet对象中，我们有时间需要转发，调用另外一个Servlet（JSP本质也是一个Servlet）：
request.getRequestDispatcher("logon").forward(request, response);
如果我们需要把一个对象传递给下一个Servlet使用，由于我们要传递多少个对象个数不是事先能确定的，属于异种不定参数个数传递，我们就需要使用Map这种形式的传递，我们在request调用setAttibute，我们就可以在下一个Servlet中使用。
4.2 Servlet几种不同生命周期。
根据Web开发具体情况，Servlet规范把变量声明周期分为request，session和application.(其实也有page,就是在service方法中声明的变量).
4.3 request变量
在Web开发中，我们可能查询满足一定条件记录。例如我们查询一个表中今天的订单记录集合并把它显示在页面中，那么我们就需要从数据库查询出该记录并传递给显示页面JSP。这个集合对象只需要在我们当前请求中使用，不需要在以后使用。
这个时间我们就考虑作为要传递的对象生命周期多长合适？过长了浪费服务器内存，短了不能满足要求，根据HttpRequest对象的生命周期：当用户请求到达服务器，Servlet引擎开始封装Http请求为HttpRequest请求，然后调用Servlet，最后Servlet的doPost等方法返回给Servlet引擎，把响应传递给浏览器，request对象的生命周期刚好符合我们这里的应用需求。这样我们就可以调用HttpRequest对象setAtrribute设置要传递的对象，我们在页面上就可以调用request对象的getAtribute获取被传递的对象。
4.3 session变量
在Web开发中，我们可能在网上购买商品，我们要浏览商品，查看各个商品的信息，然后决定是否购买。在这种情况下，我们就发出了多次请求，我们需要记录下我们购买过的商品，直到我们购买完商品结账。在Servlet中采用会话跟踪技术来满足这种应用。我们在编程时间只需要调用HttpSession接口的setAtrribute方法，就可以把我们的东西保存下来传递给同一个会话中的其他Servlet使用，使用getAtribute获取被传递的对象。
4.4 application变量
在Web开发中，我们有时间需要记录某个页面被访问的次数，这个时间不是针对某个客户，而是对所有客户的所有对该页面的访问，使用会话显然不太合适了，Servlet给我们提供了一个ServletContext接口，我们在编程时间只需要调用ServletContext接口的setAtrribute方法，就可以把我们的东西保存下来，在以后的所有Servlet都可以使用getAtribute获取被传递的对象。
5 示例程序：
5.1 request例子
5.1.1 新建一个Web项目，命名为requestDemo
5.1.2 使用 新建数据库jsptest1并执行以下脚本
/*
Navicat MySQL Data Transfer
Source Server : mysql
Source Server Version : 50509
Source Host : localhost:3306
Source Database : jsptest
Target Server Type : MYSQL
Target Server Version : 50509
File Encoding : 65001
Date: 2011-04-20 14:40:32
*/
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL,
`name` varchar(10) DEFAULT NULL,
`password` varchar(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', '张三', '123');
INSERT INTO `user` VALUES ('2', '李四', '456');
INSERT INTO `user` VALUES ('3', '王五', '789');
5.1.3 添加mysql数据驱动。
5.1.4 编写user对应的JavaBan。
package cn.hnpi;
public class User {
private String name;
private String password;
private int id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
5.1.5编写UserService方法，获取用户列表。具体方法可参考JDBC挽救实验，也可以参考下面代码，注意数据名，密码等要修改为你本机上合适的：
package cn.hnpi;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
public class UserService {
public List<User> getUserList() throws SQLException {
List<User> users = new ArrayList<User>();
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
String sql = "select * from user ";
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jsptest1", "root", "root");
stmt = conn.createStatement();
System.out.println("打开数据库连接");
rs = stmt.executeQuery(sql);
while (rs.next()) {
User user = new User();
user.setId(rs.getInt("id"));
user.setName(rs.getString("name"));
user.setPassword(rs.getString("password"));
users.add(user);
}
} catch (Exception ex) {
System.err.println("打开数据库时出错: " + ex.getMessage());
} finally {
if (rs != null) {
rs.close();
}
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
}
return users;
}
}
5.1.6 新建一个Servlet：
（1）在项目单击邮件，选择new->Servlet,弹出“new Servlet”对话框
(2)Package中输入合适的包名，在Name中输入Servlet的名称，单击“Next”。
(3)修改内容如下图所示。单击“Finish”，完成
5.1.7 修改生成的Servlet类
package cn.hnpi;
import java.io.IOException;
import java.sql.SQLException;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class UserListServlet extends HttpServlet {
/**
* Constructor of the object.
*/
public UserListServlet() {
super();
}
/**
* Destruction of the servlet. <br>
*/
public void destroy() {
super.destroy(); // Just puts "destroy" string in log
// Put your code here
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=gbk");
//1、获取用户列表,并设置到request对象中，以便传递到JSp页面显示
UserService us=new UserService();
List<User> users;
try {
users = us.getUserList();
request.setAttribute("users", users);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//2、转发,注意我们传递的是同一个request和response对象
request.getRequestDispatcher("userList.jsp").forward(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
public void init() throws ServletException {
// Put your code here
}
}
5.1.8 在WebRoot下新建JSP页面：userList.jsp
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%@page import="cn.hnpi.User"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
List<User> users=(List<User>)request.getAttribute("users");
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>用户列表</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css"
href="styles.css">
-->
</head>
<body>
<h3 align="center">用户列表</h3>
<table align="center" style="border-bottom-style: dotted;">
<tr>
<th>用户ID</th>
<th>姓名</th>
<th>密码</th>
</tr>
<%if(users!=null&&users.size()>0){
for(int i=0;i<users.size();i++){
User user=users.get(i);
%>
<tr>
<td><%=user.getId() %></td>
<td><%=user.getName()%></td>
<td><%=user.getPassword() %></td>
</tr>
<%}}else {%>
<tr><td colspan="3">无记录</td></tr>
<%} %>
</table>
</body>
</html>
5.1.9 发布并运行项目
http://lenovo-pc:8080/requestDemo/UserListServlet
5.2 Session应用项目
需求：我们要控制用户未登录时，只能通过登陆页面访问网站；一旦登陆后就不需要再重新输入密码重新登陆。这明显是针对一个客户端的多次请求，需要使用会话对象。
5.2.1 新建一个Web项目sessionDemo
5.2.2 修改index.jsp
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<!--
<link rel="stylesheet" type="text/css"
href="styles.css">
-->
</head>
<body>
<form action="LoginServlet">
<input type="text" name="name"><br/>
<input type="password" name="password"><br/>
<input type="submit">
</form>
</body>
</html>
5.2.3 新建LoginServlet
package cn.hnpi;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class LoginServlet extends HttpServlet {
/**
* Constructor of the object.
*/
public LoginServlet() {
super();
}
/**
* Destruction of the servlet. <br>
*/
public void destroy() {
super.destroy(); // Just puts "destroy" string in log
// Put your code here
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
String name=request.getParameter("name");
String password=request.getParameter("password");
if ("admin".equals(name)&&"admin".equals(password)) {
request.getSession().setAttribute("flag", 1);//记录用户是否成功登陆
request.getRequestDispatcher("success.jsp").forward(request, response);
} else {
request.getRequestDispatcher("index.jsp").forward(request, response);
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
public void init() throws ServletException {
// Put your code here
}
}
5.2.4 新建success.jsp
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%
//该代码的意思是如果用户已经登陆，那么存储在session的对象就存在且值为1；若不成立则把页面重定向到
//index.jsp页面进行登陆。从而控制未登陆时间只能从登陆页面登陆；登陆后就不需要每次请求时间都
//从登陆页面登陆
if(session.getAttribute("flag")==null||!((Integer)session.getAttribute("flag")).equals(1)){
response.sendRedirect("index.jsp");
}
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>My JSP 'success.jsp' starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<!--
<link rel="stylesheet" type="text/css"
href="styles.css">
-->
</head>
<body>
成功登陆！
</body>
</html>
5.2.5 发布运行。
用户首先输入：
http://127.0.0.1:8080/sessionDemo/success.jsp
则会重定向到index.jsp页面登陆
在用户名和密码都输入admin后成功登陆，这个时间在地址栏输入
http://127.0.0.1:8080/sessionDemo/success.jsp
就不用在重新输入密码了。
5.3 application应用
需求：我们要记录一个网页被访问的次数。这个时间是针对所有用户了，这个用别的范围变量不合适。
5.3.1 新建applicationDemo的Web项目
5.3.2 修改页面index.jsp
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'index.jsp' starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css"
href="styles.css">
-->
</head>
<body>
<%
Integer counter=0;
if( application.getAttribute("counter")==null){
application.setAttribute("counter",1);
counter++;
}else{
counter= (Integer)application.getAttribute("counter")+1;
application.setAttribute("counter",counter);
}
%>
该页面被访问了<%=counter %>次
</body>
</html>
5.3.3 发布运行
用户可以打开多个浏览器窗口测试，看看是否正确记录了访问次数。
JAVA写入Mysql中文乱码解决方法
页面传值中有中文的时候，可以使用filter来搞掂，可是好容易System.out.println可以出中文了，插入到Mysql里，还是乱码。
怎么办呢，做到以下几点：
1。创建数据库的时候：
CREATE DATABASE `Db`
CHARACTER SET 'utf8 '
COLLATE 'utf8_general_ci ';
2.建表的时候:
CREATE TABLE `TableA` (
`ID` varchar(40) NOT NULL default ' ',
`UserID` varchar(40) NOT NULL default ' ', )
ENGINE=InnoDB DEFAULT CHARSET=utf8;
3.设置URL的时候:
jdbc:mysql://localhost:3306/database?useUnicode=true&characterEncoding=UTF-8
JDBC挽救实验
JDBC挽救实验
1说明：本指导主要讲述如何使用Mysql客户端建立数据库、执行脚本和使用
JDBC编程。
2 Mysql客户端的使用(在MyEclipse中)
2.1 在MyEclipse菜单中选择:Window->Show View->other…,出现“Show
View”对话框，在上部文本框输入DB，就会看到DB Browser，双击，就会在
MyEclipse中显示该视图。如图2.2 右下底部。
2.3
1、在DB Browser右击，选择某个已有的数据连接配置名称，在弹出菜单中选
择：Open Connetion…打开连接。
2、新建
具体操作见Pdf文档
3JDBC编程(Java项目)
3.1新建一个Java项目：MyEclipse中选择菜单：File->New->Java Project，此时出现 “New
Java Project”向导对话框，如图1：在“Project name”输入项目名(不要用中文名称)，然后单
击“Finsh”按钮完成项目创建。此时在图2中左侧“Package Explorer”窗格出现新建的项
目，在“JDBCDemo”项目上双击可以展开和折叠项目。
图1 新建项目向导
图2 完成项目创建
3.2 添加Mysql驱动：
方法一：
在“JDBCDemo”项目上右击，选择 Properties，将出现下图的对话框：首先左侧单
击“Java Build Path”，然后在右侧选择“Libraries”页，然后单击“Add External
JARS…”按钮，出现“JAR Select”对话框，找到Mysql驱动器所在的位置，然后选中，单
击“打开”，就完成了Mysql的JDBC添加。（MyEclipse中添加Jar类库方法都如此）.
图3 项目属性对话框
4 JAR文件选择对话框
3.3 建立数据表user对应的JavaBean类User。
1、这种JavaBean一般放到*.entity包内，在本例中我们把它放到cn.hnpi.
java1002.entity包中。
2、新建一个Java类，右击项目,选择New->Class，出现“New Java Class”对话框，
在“Package”中输入“cn.hnpi.java1002.entity”，在“Name”中输入User，单
击“Finsh”按钮，此时在Myeclipse中显示出新建的类。
3、输入两个字段：userName和userPwd.
4、为该字段生成getter/setter方法
在上图中间，右击出现快捷菜单，选择Source->Generate getters and setters…，此时出
现“Generate getters and setters”对话框，单击“Select All”按钮，然后单击“OK”按钮，
完成方法生成。此时的User满足JavaBean规范要求：（1）类非final；（2）属性私有；
（3）公有的getter和setter方法；(3)有一个无参的构造函数。
3.4 在该项目新建四个类:DelUser,AddUser,UpdateUser和SelectUser，他们都位
于cn.hnpi.java1002.dao包中。对数据库的操作基本就是增、删、改和查
（CRUD）。
1、AddUser：
package cn.hnpi.java1002.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class AddUser {
public static void main(String[] args) throws SQLException {
//1、加载驱动器,注意forName中给出包名加类名（即全限定名）
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Connection conn=null;
Statement stmt=null;
try {
//2、获取到数据库的连接:jdbc:mysql://是数据库协议，127.0.0.1是IP地址，
本机用这个IP，3306端口号，jdbctest数据库名称
//第二个参数是数据库用户名，第三个参数是密码。
conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/
jsptest", "root", "root");
//3.1、准备sql语句
String sql="insert into user values(4,'zhangsan','123')";
//3.2，获取Statement对象来执行语句
stmt=conn.createStatement();
//3.3执行语句，由于insert，delete和update通常调用executeUpdate,不成功
返回0
int result=stmt.executeUpdate(sql);
if (result==0) {
System.out.println("添加失败");
} else {
System.out.println("添加成功");
}
} catch (SQLException e) {//5、异常处理
// TODO Auto-generated catch block
e.printStackTrace();
}finally{//4、关闭数据库：先关闭Statement对象，然后是Connection对象
if(stmt!=null){
stmt.close();
}
if(conn!=null){
conn.close();
}
}
}
}
2、DelUser
package cn.hnpi.java1002.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
public class DelUser {
public static void main(String[] args) throws SQLException {
//1、加载驱动器,注意forName中给出包名加类名（即全限定名）
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Connection conn=null;
PreparedStatement pstmt=null;
try {
//2、获取到数据库的连接:jdbc:mysql://是数据库协议，127.0.0.1是IP地
址，本机用这个IP，3306端口号，jdbctest数据库名称
//第二个参数是数据库用户名，第三个参数是密码。
conn=DriverManager.getConnection("jdbc:
mysql://127.0.0.1:3306/jsptest", "root", "root");
//3.1、准备sql语句
String sql="delete from user where id=?";
//3.2，获取Statement对象来执行语句
pstmt=conn.prepareStatement(sql);
pstmt.setInt(1, 4);
//3.3执行语句，由于insert，delete和update通常调用executeUpdate,不
成功返回0
int result=pstmt.executeUpdate();
if (result==0) {
System.out.println("删除失败");
} else {
System.out.println("删除成功");
}
} catch (SQLException e) {//5、异常处理
// TODO Auto-generated catch block
e.printStackTrace();
}finally{//4、关闭数据库：先关闭Statement对象，然后是Connection对象
if(pstmt!=null){
pstmt.close();
}
if(conn!=null){
conn.close();
}
}
}
}
3、Update
package cn.hnpi.java1002.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class UpdateUser {
public static void main(String[] args) throws SQLException {
//1、加载驱动器,注意forName中给出包名加类名（即全限定名）
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Connection conn=null;
PreparedStatement pstmt=null;
try {
//2、获取到数据库的连接:jdbc:mysql://是数据库协议，127.0.0.1是IP地
址，本机用这个IP，3306端口号，jdbctest数据库名称
//第二个参数是数据库用户名，第三个参数是密码。
conn=DriverManager.getConnection("jdbc:
mysql://127.0.0.1:3306/jsptest", "root", "root");
//3.1、准备sql语句
String sql="update user set password=? where id=?";
//3.2，获取Statement对象来执行语句
pstmt=conn.prepareStatement(sql);
//3.2password在数据库中是字符型
pstmt.setString(1, "1234");
pstmt.setInt(2, 1);
//3.3执行语句，由于insert，delete和update通常调用executeUpdate,不
成功返回0
int result=pstmt.executeUpdate();
if (result==0) {
System.out.println("更新失败");
} else {
System.out.println("更新成功");
}
} catch (SQLException e) {//5、异常处理
// TODO Auto-generated catch block
e.printStackTrace();
}finally{//4、关闭数据库：先关闭Statement对象，然后是Connection对象
if(pstmt!=null){
pstmt.close();
}
if(conn!=null){
conn.close();
}
}
}
}
4、SelectUser：查询用户 package cn.hnpi.java1002.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import cn.hnpi.java1002.entity.User;
public class SelectUser {
public static void main(String[] args) throws SQLException {
//1、加载驱动器类,注意forName中给出包名加类名（即全限定名）
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Connection conn=null;//数据库连接对象
Statement stmt=null;
ResultSet rs=null;
try {
//2、获取到数据库的连接:jdbc:mysql://是数据库协议，127.0.0.1是IP地
址，本机用这个IP，3306端口号，jdbctest数据库名称
//第二个参数是数据库用户名，第三个参数是密码。
conn=DriverManager.getConnection("jdbc:
mysql://127.0.0.1:3306/jsptest", "root", "root");
//3.1、准备sql语句
String sql="select * from user";
//3.2，获取Statement对象来执行语句
stmt=conn.createStatement();
//3.3执行语句，检索结果
rs=stmt.executeQuery(sql);
List<User> users=new ArrayList<User>();
while (rs.next()) {
User user=new User();
user.setUserName(rs.getString("name"));
user.setUserPwd(rs.getString("password"));
users.add(user);
System.out.println("name="+user.getUserName()+";
password="+user.getUserPwd());
}
} catch (SQLException e) {//5、异常处理
// TODO Auto-generated catch block
e.printStackTrace();
}finally{//4、关闭数据库：先关闭Statement对象，然后是Connection对象
if(rs!=null){
rs.close();
}
if(stmt!=null){
stmt.close();
}
if(conn!=null){
conn.close();
}
}
}
}
4、思考题目：
1、我们发现这四个类中如：数据库驱动加载，连接对象获取；对象关闭都是
相同的，我们如何重构使得代码量减少。
2、使用JDBC编程工作量在那一部分？使用JDBC需要的基础是什么？
1. 在Java语言中，有类变量、实例变量、方法变量和代码块变量，每种变量都有自己的作用域和生命周期。
public class VariableScopeDemo {
/*1、类变量，生命周期：从该类被虚拟机加载直到到该类被卸载，该变量都存在；
* 作用域：可以被该类的所有实例访问*/
private static double PI=3.1415926;
/*2、实例变量，生命周期：从该类的一个实例创建到被垃圾回收，该变量存在；
* 作用域：可以被该实例的所有方法中使用
* **/
private double radius;
public double square(){
/*
* 3、方法变量，生命周期：从该被调用，运行到变量的声明处到该方法返回，该变量都存在
* 作用域：变量的声明到方法结束前都可以访问
* */
double square=PI*radius*radius;//square声明周期开始
/**
*4、 代码块，其中K是代码块变量，生命周期：从代码块中声明该变量开始到代码块结束
* 作用域：从代码块中声明该变量开始到代码块结束
* */
{
int k=0;//k生命周期开始
k++;
}//k生命周期结束
return square;
}//square声明周期结束
public double zhouchang(){
double zhouchang=2*PI*radius;
return zhouchang;
}
public void setRadius(double radius) {
this.radius = radius;
}
}
2、为什么要有这么多变量类型？我们知道程序运行时间变量都会被分配内存。比如方法变量，在方法调用结束后，我们就不需要该变量了，这时间就可以释放它占用的内存。由于内存不是无限的，在一个变量不需要使用的时候，我们就要及时释放它占用的内存，以免内存被耗尽。
3、Java中不定参数的传递方法。
3.1 同种类型变量传递，比如我们常见的主方法。可以接收不定个数的字符串参数
public static void main(String[] args) {
}
3.2 异种类型变量传递。方法是参数是一个Map，这样我们就可以传递不定参数进去。
import java.util.HashMap;
import java.util.Map;
//该对象用户封装请求请求参数，模拟HttpRequest对象
public class Request {
Map<String, Object> parameter=new HashMap<String, Object>();
public void setAttibute(String name,Object value){
parameter.put(name, value);
}
public Object getAttibute(String name){
return parameter.get(name);
}
}
//该方法用于模拟我们怎么创建在一个方法中设置对象，并把它作为参数传递给//另外一个函数
public class VariableParameterDemo {
public static void test(Request request){
Integer age=(Integer) request.getAttibute("age");
String name=(String) request.getAttibute("name");
System.out.println("age="+age+";name="+name);
}
public static void main(String[] args) {
Request mapP=new Request();
mapP.setAttibute("age", new Integer(20));
mapP.setAttibute("name", "zhangsan");
//我们通过Request对象把不定参数的对象传递给了test方法。
test(mapP);
}
}
4、Servlet对象之间对象传递。
4.1在Servlet对象中，我们有时间需要转发，调用另外一个Servlet（JSP本质也是一个Servlet）：
request.getRequestDispatcher("logon").forward(request, response);
如果我们需要把一个对象传递给下一个Servlet使用，由于我们要传递多少个对象个数不是事先能确定的，属于异种不定参数个数传递，我们就需要使用Map这种形式的传递，我们在request调用setAttibute，我们就可以在下一个Servlet中使用。
4.2 Servlet几种不同生命周期。
根据Web开发具体情况，Servlet规范把变量声明周期分为request，session和application.(其实也有page,就是在service方法中声明的变量).
4.3 request变量
在Web开发中，我们可能查询满足一定条件记录。例如我们查询一个表中今天的订单记录集合并把它显示在页面中，那么我们就需要从数据库查询出该记录并传递给显示页面JSP。这个集合对象只需要在我们当前请求中使用，不需要在以后使用。
这个时间我们就考虑作为要传递的对象生命周期多长合适？过长了浪费服务器内存，短了不能满足要求，根据HttpRequest对象的生命周期：当用户请求到达服务器，Servlet引擎开始封装Http请求为HttpRequest请求，然后调用Servlet，最后Servlet的doPost等方法返回给Servlet引擎，把响应传递给浏览器，request对象的生命周期刚好符合我们这里的应用需求。这样我们就可以调用HttpRequest对象setAtrribute设置要传递的对象，我们在页面上就可以调用request对象的getAtribute获取被传递的对象。
4.3 session变量
在Web开发中，我们可能在网上购买商品，我们要浏览商品，查看各个商品的信息，然后决定是否购买。在这种情况下，我们就发出了多次请求，我们需要记录下我们购买过的商品，直到我们购买完商品结账。在Servlet中采用会话跟踪技术来满足这种应用。我们在编程时间只需要调用HttpSession接口的setAtrribute方法，就可以把我们的东西保存下来传递给同一个会话中的其他Servlet使用，使用getAtribute获取被传递的对象。
4.4 application变量
在Web开发中，我们有时间需要记录某个页面被访问的次数，这个时间不是针对某个客户，而是对所有客户的所有对该页面的访问，使用会话显然不太合适了，Servlet给我们提供了一个ServletContext接口，我们在编程时间只需要调用ServletContext接口的setAtrribute方法，就可以把我们的东西保存下来，在以后的所有Servlet都可以使用getAtribute获取被传递的对象。
5 示例程序：
5.1 request例子
5.1.1 新建一个Web项目，命名为requestDemo
5.1.2 使用 新建数据库jsptest1并执行以下脚本
/*
Navicat MySQL Data Transfer
Source Server : mysql
Source Server Version : 50509
Source Host : localhost:3306
Source Database : jsptest
Target Server Type : MYSQL
Target Server Version : 50509
File Encoding : 65001
Date: 2011-04-20 14:40:32
*/
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL,
`name` varchar(10) DEFAULT NULL,
`password` varchar(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', '张三', '123');
INSERT INTO `user` VALUES ('2', '李四', '456');
INSERT INTO `user` VALUES ('3', '王五', '789');
5.1.3 添加mysql数据驱动。
5.1.4 编写user对应的JavaBan。
package cn.hnpi;
public class User {
private String name;
private String password;
private int id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
5.1.5编写UserService方法，获取用户列表。具体方法可参考JDBC挽救实验，也可以参考下面代码，注意数据名，密码等要修改为你本机上合适的：
package cn.hnpi;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
public class UserService {
public List<User> getUserList() throws SQLException {
List<User> users = new ArrayList<User>();
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
String sql = "select * from user ";
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jsptest1", "root", "root");
stmt = conn.createStatement();
System.out.println("打开数据库连接");
rs = stmt.executeQuery(sql);
while (rs.next()) {
User user = new User();
user.setId(rs.getInt("id"));
user.setName(rs.getString("name"));
user.setPassword(rs.getString("password"));
users.add(user);
}
} catch (Exception ex) {
System.err.println("打开数据库时出错: " + ex.getMessage());
} finally {
if (rs != null) {
rs.close();
}
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
}
return users;
}
}
5.1.6 新建一个Servlet：
（1）在项目单击邮件，选择new->Servlet,弹出“new Servlet”对话框
(2)Package中输入合适的包名，在Name中输入Servlet的名称，单击“Next”。
(3)修改内容如下图所示。单击“Finish”，完成
5.1.7 修改生成的Servlet类
package cn.hnpi;
import java.io.IOException;
import java.sql.SQLException;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class UserListServlet extends HttpServlet {
/**
* Constructor of the object.
*/
public UserListServlet() {
super();
}
/**
* Destruction of the servlet. <br>
*/
public void destroy() {
super.destroy(); // Just puts "destroy" string in log
// Put your code here
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=gbk");
//1、获取用户列表,并设置到request对象中，以便传递到JSp页面显示
UserService us=new UserService();
List<User> users;
try {
users = us.getUserList();
request.setAttribute("users", users);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//2、转发,注意我们传递的是同一个request和response对象
request.getRequestDispatcher("userList.jsp").forward(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
public void init() throws ServletException {
// Put your code here
}
}
5.1.8 在WebRoot下新建JSP页面：userList.jsp
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%@page import="cn.hnpi.User"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
List<User> users=(List<User>)request.getAttribute("users");
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>用户列表</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css"
href="styles.css">
-->
</head>
<body>
<h3 align="center">用户列表</h3>
<table align="center" style="border-bottom-style: dotted;">
<tr>
<th>用户ID</th>
<th>姓名</th>
<th>密码</th>
</tr>
<%if(users!=null&&users.size()>0){
for(int i=0;i<users.size();i++){
User user=users.get(i);
%>
<tr>
<td><%=user.getId() %></td>
<td><%=user.getName()%></td>
<td><%=user.getPassword() %></td>
</tr>
<%}}else {%>
<tr><td colspan="3">无记录</td></tr>
<%} %>
</table>
</body>
</html>
5.1.9 发布并运行项目
http://lenovo-pc:8080/requestDemo/UserListServlet
5.2 Session应用项目
需求：我们要控制用户未登录时，只能通过登陆页面访问网站；一旦登陆后就不需要再重新输入密码重新登陆。这明显是针对一个客户端的多次请求，需要使用会话对象。
5.2.1 新建一个Web项目sessionDemo
5.2.2 修改index.jsp
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<!--
<link rel="stylesheet" type="text/css"
href="styles.css">
-->
</head>
<body>
<form action="LoginServlet">
<input type="text" name="name"><br/>
<input type="password" name="password"><br/>
<input type="submit">
</form>
</body>
</html>
5.2.3 新建LoginServlet
package cn.hnpi;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class LoginServlet extends HttpServlet {
/**
* Constructor of the object.
*/
public LoginServlet() {
super();
}
/**
* Destruction of the servlet. <br>
*/
public void destroy() {
super.destroy(); // Just puts "destroy" string in log
// Put your code here
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
String name=request.getParameter("name");
String password=request.getParameter("password");
if ("admin".equals(name)&&"admin".equals(password)) {
request.getSession().setAttribute("flag", 1);//记录用户是否成功登陆
request.getRequestDispatcher("success.jsp").forward(request, response);
} else {
request.getRequestDispatcher("index.jsp").forward(request, response);
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
public void init() throws ServletException {
// Put your code here
}
}
5.2.4 新建success.jsp
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%
//该代码的意思是如果用户已经登陆，那么存储在session的对象就存在且值为1；若不成立则把页面重定向到
//index.jsp页面进行登陆。从而控制未登陆时间只能从登陆页面登陆；登陆后就不需要每次请求时间都
//从登陆页面登陆
if(session.getAttribute("flag")==null||!((Integer)session.getAttribute("flag")).equals(1)){
response.sendRedirect("index.jsp");
}
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>My JSP 'success.jsp' starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<!--
<link rel="stylesheet" type="text/css"
href="styles.css">
-->
</head>
<body>
成功登陆！
</body>
</html>
5.2.5 发布运行。
用户首先输入：
http://127.0.0.1:8080/sessionDemo/success.jsp
则会重定向到index.jsp页面登陆
在用户名和密码都输入admin后成功登陆，这个时间在地址栏输入
http://127.0.0.1:8080/sessionDemo/success.jsp
就不用在重新输入密码了。
5.3 application应用
需求：我们要记录一个网页被访问的次数。这个时间是针对所有用户了，这个用别的范围变量不合适。
5.3.1 新建applicationDemo的Web项目
5.3.2 修改页面index.jsp
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'index.jsp' starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css"
href="styles.css">
-->
</head>
<body>
<%
Integer counter=0;
if( application.getAttribute("counter")==null){
application.setAttribute("counter",1);
counter++;
}else{
counter= (Integer)application.getAttribute("counter")+1;
application.setAttribute("counter",counter);
}
%>
该页面被访问了<%=counter %>次
</body>
</html>
5.3.3 发布运行
用户可以打开多个浏览器窗口测试，看看是否正确记录了访问次数。
JAVA写入Mysql中文乱码解决方法
页面传值中有中文的时候，可以使用filter来搞掂，可是好容易System.out.println可以出中文了，插入到Mysql里，还是乱码。
怎么办呢，做到以下几点：
1。创建数据库的时候：
CREATE DATABASE `Db`
CHARACTER SET 'utf8 '
COLLATE 'utf8_general_ci ';
2.建表的时候:
CREATE TABLE `TableA` (
`ID` varchar(40) NOT NULL default ' ',
`UserID` varchar(40) NOT NULL default ' ', )
ENGINE=InnoDB DEFAULT CHARSET=utf8;
3.设置URL的时候:
jdbc:mysql://localhost:3306/database?useUnicode=true&characterEncoding=UTF-8
JDBC挽救实验
JDBC挽救实验
1说明：本指导主要讲述如何使用Mysql客户端建立数据库、执行脚本和使用
JDBC编程。
2 Mysql客户端的使用(在MyEclipse中)
2.1 在MyEclipse菜单中选择:Window->Show View->other…,出现“Show
View”对话框，在上部文本框输入DB，就会看到DB Browser，双击，就会在
MyEclipse中显示该视图。如图2.2 右下底部。
2.3
1、在DB Browser右击，选择某个已有的数据连接配置名称，在弹出菜单中选
择：Open Connetion…打开连接。
2、新建
具体操作见Pdf文档
3JDBC编程(Java项目)
3.1新建一个Java项目：MyEclipse中选择菜单：File->New->Java Project，此时出现 “New
Java Project”向导对话框，如图1：在“Project name”输入项目名(不要用中文名称)，然后单
击“Finsh”按钮完成项目创建。此时在图2中左侧“Package Explorer”窗格出现新建的项
目，在“JDBCDemo”项目上双击可以展开和折叠项目。
图1 新建项目向导
图2 完成项目创建
3.2 添加Mysql驱动：
方法一：
在“JDBCDemo”项目上右击，选择 Properties，将出现下图的对话框：首先左侧单
击“Java Build Path”，然后在右侧选择“Libraries”页，然后单击“Add External
JARS…”按钮，出现“JAR Select”对话框，找到Mysql驱动器所在的位置，然后选中，单
击“打开”，就完成了Mysql的JDBC添加。（MyEclipse中添加Jar类库方法都如此）.
图3 项目属性对话框
4 JAR文件选择对话框
3.3 建立数据表user对应的JavaBean类User。
1、这种JavaBean一般放到*.entity包内，在本例中我们把它放到cn.hnpi.
java1002.entity包中。
2、新建一个Java类，右击项目,选择New->Class，出现“New Java Class”对话框，
在“Package”中输入“cn.hnpi.java1002.entity”，在“Name”中输入User，单
击“Finsh”按钮，此时在Myeclipse中显示出新建的类。
3、输入两个字段：userName和userPwd.
4、为该字段生成getter/setter方法
在上图中间，右击出现快捷菜单，选择Source->Generate getters and setters…，此时出
现“Generate getters and setters”对话框，单击“Select All”按钮，然后单击“OK”按钮，
完成方法生成。此时的User满足JavaBean规范要求：（1）类非final；（2）属性私有；
（3）公有的getter和setter方法；(3)有一个无参的构造函数。
3.4 在该项目新建四个类:DelUser,AddUser,UpdateUser和SelectUser，他们都位
于cn.hnpi.java1002.dao包中。对数据库的操作基本就是增、删、改和查
（CRUD）。
1、AddUser：
package cn.hnpi.java1002.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class AddUser {
public static void main(String[] args) throws SQLException {
//1、加载驱动器,注意forName中给出包名加类名（即全限定名）
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Connection conn=null;
Statement stmt=null;
try {
//2、获取到数据库的连接:jdbc:mysql://是数据库协议，127.0.0.1是IP地址，
本机用这个IP，3306端口号，jdbctest数据库名称
//第二个参数是数据库用户名，第三个参数是密码。
conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/
jsptest", "root", "root");
//3.1、准备sql语句
String sql="insert into user values(4,'zhangsan','123')";
//3.2，获取Statement对象来执行语句
stmt=conn.createStatement();
//3.3执行语句，由于insert，delete和update通常调用executeUpdate,不成功
返回0
int result=stmt.executeUpdate(sql);
if (result==0) {
System.out.println("添加失败");
} else {
System.out.println("添加成功");
}
} catch (SQLException e) {//5、异常处理
// TODO Auto-generated catch block
e.printStackTrace();
}finally{//4、关闭数据库：先关闭Statement对象，然后是Connection对象
if(stmt!=null){
stmt.close();
}
if(conn!=null){
conn.close();
}
}
}
}
2、DelUser
package cn.hnpi.java1002.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
public class DelUser {
public static void main(String[] args) throws SQLException {
//1、加载驱动器,注意forName中给出包名加类名（即全限定名）
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Connection conn=null;
PreparedStatement pstmt=null;
try {
//2、获取到数据库的连接:jdbc:mysql://是数据库协议，127.0.0.1是IP地
址，本机用这个IP，3306端口号，jdbctest数据库名称
//第二个参数是数据库用户名，第三个参数是密码。
conn=DriverManager.getConnection("jdbc:
mysql://127.0.0.1:3306/jsptest", "root", "root");
//3.1、准备sql语句
String sql="delete from user where id=?";
//3.2，获取Statement对象来执行语句
pstmt=conn.prepareStatement(sql);
pstmt.setInt(1, 4);
//3.3执行语句，由于insert，delete和update通常调用executeUpdate,不
成功返回0
int result=pstmt.executeUpdate();
if (result==0) {
System.out.println("删除失败");
} else {
System.out.println("删除成功");
}
} catch (SQLException e) {//5、异常处理
// TODO Auto-generated catch block
e.printStackTrace();
}finally{//4、关闭数据库：先关闭Statement对象，然后是Connection对象
if(pstmt!=null){
pstmt.close();
}
if(conn!=null){
conn.close();
}
}
}
}
3、Update
package cn.hnpi.java1002.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class UpdateUser {
public static void main(String[] args) throws SQLException {
//1、加载驱动器,注意forName中给出包名加类名（即全限定名）
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Connection conn=null;
PreparedStatement pstmt=null;
try {
//2、获取到数据库的连接:jdbc:mysql://是数据库协议，127.0.0.1是IP地
址，本机用这个IP，3306端口号，jdbctest数据库名称
//第二个参数是数据库用户名，第三个参数是密码。
conn=DriverManager.getConnection("jdbc:
mysql://127.0.0.1:3306/jsptest", "root", "root");
//3.1、准备sql语句
String sql="update user set password=? where id=?";
//3.2，获取Statement对象来执行语句
pstmt=conn.prepareStatement(sql);
//3.2password在数据库中是字符型
pstmt.setString(1, "1234");
pstmt.setInt(2, 1);
//3.3执行语句，由于insert，delete和update通常调用executeUpdate,不
成功返回0
int result=pstmt.executeUpdate();
if (result==0) {
System.out.println("更新失败");
} else {
System.out.println("更新成功");
}
} catch (SQLException e) {//5、异常处理
// TODO Auto-generated catch block
e.printStackTrace();
}finally{//4、关闭数据库：先关闭Statement对象，然后是Connection对象
if(pstmt!=null){
pstmt.close();
}
if(conn!=null){
conn.close();
}
}
}
}
4、SelectUser：查询用户 package cn.hnpi.java1002.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import cn.hnpi.java1002.entity.User;
public class SelectUser {
public static void main(String[] args) throws SQLException {
//1、加载驱动器类,注意forName中给出包名加类名（即全限定名）
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Connection conn=null;//数据库连接对象
Statement stmt=null;
ResultSet rs=null;
try {
//2、获取到数据库的连接:jdbc:mysql://是数据库协议，127.0.0.1是IP地
址，本机用这个IP，3306端口号，jdbctest数据库名称
//第二个参数是数据库用户名，第三个参数是密码。
conn=DriverManager.getConnection("jdbc:
mysql://127.0.0.1:3306/jsptest", "root", "root");
//3.1、准备sql语句
String sql="select * from user";
//3.2，获取Statement对象来执行语句
stmt=conn.createStatement();
//3.3执行语句，检索结果
rs=stmt.executeQuery(sql);
List<User> users=new ArrayList<User>();
while (rs.next()) {
User user=new User();
user.setUserName(rs.getString("name"));
user.setUserPwd(rs.getString("password"));
users.add(user);
System.out.println("name="+user.getUserName()+";
password="+user.getUserPwd());
}
} catch (SQLException e) {//5、异常处理
// TODO Auto-generated catch block
e.printStackTrace();
}finally{//4、关闭数据库：先关闭Statement对象，然后是Connection对象
if(rs!=null){
rs.close();
}
if(stmt!=null){
stmt.close();
}
if(conn!=null){
conn.close();
}
}
}
}
4、思考题目：
1、我们发现这四个类中如：数据库驱动加载，连接对象获取；对象关闭都是
相同的，我们如何重构使得代码量减少。
2、使用JDBC编程工作量在那一部分？使用JDBC需要的基础是什么？
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 数据库连接不关闭造成的问题以及RowSet的使用
- Metasploit中数据库的密码查看以及使用pgadmin远程连接数据库
- mysql的安装与简单使用以及myeclipse下与数据库的连接和使用
- servlet（三）-如何使用传参-三种转发方式、传递参数以及对象中数据的范围
- python下使用mysql.connector 安装以及连接数据库的操作
- Adobe AIR中使用Flex连接Sqlite数据库(1)(创建数据库和表,以及同步和异步执行模式)
- java_web 第三课servlet使用jdbc连接数据库
- 使用JDBC连接数据库遇到的问题，以及查找到的解决方法
- servlet交互案例分析及终极实现 使用jdbc连接数据库实现
- 数据库连接、读取（查询）以及赋值给变量过程
- servlet（三）-如何使用传参-三种转发方式、传递参数以及对象中数据的范围
- spring mybatis不能使用变量连接数据库
- 利用javabean轻松实现对数据库的连接、查询以及增删改！------使用范例
- JDBC连接数据库使用SERVICE NAME、SID以及TNSName不同写法
- SQL Server知识点：数据库之局部变量的定义、赋值、以及使用
- 使用servlet连接数据库
- 关于数据库连接未及时关闭的系统报错， 以及该过程中使用DataSet和DataReader的区别
- 使用 servlet 连接数据库
- 使用第三方jar包连接数据库以及数据库连接池
- 韩顺平servlet学习笔记02-session以及连接数据库