servlet学习总结：
1常用的服务器：首先用TCP/IP连接到新浪的服务器上，从新浪首页上拿出新浪的代码，然后IE解析。
（1）IIS
（2）Apache （linux用的最多的）是一种web服务器，使用C语言写的
（3）Tomcat是Apache 总项目的一个，也是一种web服务器，是用java语言写的。叫做jsp和servelet的容器。
2.动态的网页技术：根据客户端不同的情况来选择不同的展现。同一个页面可以展现出不同的结果。
CGI（Common GateWay Interface）
API(NSAPI ,ISAPI)
ASP(active server page)
PHP(personal home page)
JSP/servelet(java server page)
3 servelet 简介：
（1）servelet 是一个服务器小应用程序。
（2）用来完成B/S架构下，客户端请求的响应处理
（3）平台独立，性能优良，能以线程的方式运行。
（4）Servelet一般在容器中运行。
（5）常见的servlet容器：Tomcat
4.Servlet程序的创建：
（1）解压servlet-api.jar，看是否于j2ee的API文档相对应，里面都是些class文件
（2）从tomcat容器中引入servlet-api.jar包，为什么要引入这个jar包呢？其实这个jar包就是对j2ee的API文档的接口的实现。所以在写servlet,要实现某个接口，你当然必须拥有这个接口的class文件，所以要引入这个servlet-api.jar包。
（3）servelet除了可以再web服务器端运行，还可以在其他服务器端运行。而httpServelet是给web服务器使用的一个servelet
（4）httpServelet是一个abtract，当客户端请求一个url时会调用它，根据不同的请求会调用不同的方法。针对不同的请求会调用不同的方法，当你的请求是get方式时，就会调用doGet（）方法，当你的请求是post时，就会调用dopost方法
5.Servlet 的生命周期
Servlet简介：
1.定义：Sevlet（服务器端小程序）是使用java语言编写的服务器端程序，可以向jsp一样生成动态web页面。Sevlet主要运行在服务器端，并用服务器调用执行，是一种按照servlet标准开发的类。
2.Servlet带给开发人员的最大的好处是：它可以处理客户端传来的HTTP请求，并返回一个响应。
3.Servlet 将按照如下步骤进行处理：
（1）客户端（很可能是web浏览器）通过Http提出请求
（2）Web服务器接收请求并将其发给Servlet。
（3）Servlet程序将接收该http请求并执行某种处理。
（4）Servlet会将处理后的结果向web服务器返回应答。
（5）Web服务器将从Servlet收到的应答发回给客户端。
4.在整个程序中最重要的就是Servlet接口，在此接口下定义了GenericSevlet的子类但一般不会直接继承此类，而是根据所使用的协议选择GenericServlet的子类继承。
HttpServeletRequest和HttpServeletResponse，用来接收和回应用户的请求。
5.Servlet 的生命周期全过程：
（1）加载：把servlet.class文件load进来放到web容器里。
（2）实例化：new 一个servlet对象出来。
（3）初始化：web容器调用init（）方法初始化这个对象。
初始化的目的是为了让Servlet在处理客户端请求前完成一些初始化的工作，如建立数据库的连接、读取资源文件信息等。
（4）处理服务：servlet将调用service方法，对于httpServlet将会调用doget()方法或者doPost()方法进行处理。
（5）销毁：当web容器关闭时或者检测到要从容器被删除时，会自动调用destroy方法，以便让该实例释放掉所占用的内存。
对应的代码：
（1）public TestLifeCircleServlet() { }
(2)public void init(ServletConfig config) throws ServletException {}
(3)public void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {}
理解servelt的生命周期测试代码总结：
（1）测试这几个方法先后的执行顺序,经过测试先构建对象
（2）只是构建一个对象，不管你访问多少次，只是由这一个对象提供服务，在初始化，最后调用doGet方法
（3）servlet不管你访问多少次，只构建一个对象，访问几次调用几次doGet()方法,init方法只执行一次，第一次初始化的时候执行
（4）当webapp退出时，会调用destroy方法，也就是说servlet对象真正的从内存中消失时，才会调用destroy方法
（5）ServletConfig 中的config对象可以读取web.xml中的初始化参数，得到servlet的配置信息
（6）怎样在浏览器中对servlet程序进行访问：
<servlet> <servlet-name>hello</servlet-name>
<servlet-class>hello</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
在浏览器输入：http://localhost:8080/Filter/hello 对servlet进行访问
6.Cookie的原理
浏览器要访问服务器里面的文件，只要在浏览器里面写这个文件名，写服务器的地址，写端口号，写http，要想传参数，直接在地址里面传，或者通过post方式来传。
http协议的无连接性，要求出现一种保存c/s间状态的机制：
通过浏览器访问网页1，买了一个东西（登陆了），当我们从服务器拿下我么的内容之后，浏览器到服务器的连接就断掉了（无连接性）；买完东西（登陆后）去另外一个页面网页2结账，所以去第一个页面买的东西要保存下来。
怎么保存第一个页面买东西的记录呢？
答案：把买东西的记录写在客户端。服务器端在客户端写入的东西，就叫做cookie。
当结账的时候，网页2就会到客户端把第一个页面保存在客户端的记录拿出来，即把cookie拿到，然后结账。
需要注意的地方：
1服务器可以向客户端写内容，只能是文本内容。（不能写其他的文件，否则会不安全）
2客户端可以阻止服务器端写入。
3.服务器端只能拿自己webapp写入的的东西。（网页2结账时，需要从客户端取出记录，然后结账）
4.cookie就是服务器端写入客户端的这些个小文本的信息。Cookie以“名-值”对的形式保存数据。
5.登陆后两个星期不用再登陆。就是服务器把信息保存在了客户端的cookie里面了。
Cookie分为两种：（1）属于窗口（子窗口）（2）属于文本的
一种写在文件里，一种是相当于你写入内存里，只要你把浏览器关掉，这个cookie就消失。服务器端写在客户端，如果设置了生存周期，会写在我们的文件里面，如果没有设置，他会写在我们客户端的内存里面。当浏览器窗口一关，这个cookie就消失了。
Session的工作原理 ：记录在服务器
原理：当浏览器访问某个页面时，会在服务器端开辟一块内存，而这块内存是跟你的浏览器窗口（子窗口）关联到一起的。只要我愿意的话，我会给你的浏览器来建立一个session，然后这个session只能由你这个浏览器来访问。另外一个浏览器也想记录自己的状态，怎么办？再起一个单独的session，来和我们这个浏览器关联在一起。
理解：你访问我第一个页面时，我给你的浏览器创造独一无二的号码，我也给你创建的session赋予同样的号码，在服务器端记录着一系列的session，当你在访问第二个页面时，请你把号码发给我第二个页面，我第二个页面再找你这个号码和我们原来session2对应的那个session2。这个号码就叫做sessionId
Session的两种实现方式：（1）通过Cookies来实现（2）通过url重写来实现
所谓通过Cookies来实现说的是什么意思？
每一个客户端你要想支持session的话，你必须在访问我的页面的时候把你的sessionID传递给我。你怎么样才能把这个sessionID传递给我呢？
（1）通过Cookies来实现：我们可以把这个sessionID存在Cookies里面。存在临时的内存里面，浏览器窗口关了，sessionID就不需要了，浏览器窗口关了，永远不会有人来访问你这个浏览器对应的session了.如果浏览器支持Cookies（可以通过设置浏览器不让支持Cookie），创建session时就会把sessionID保存在Cookie里面。（如果不允许Cookie，在IE里面可能禁掉，在fireFox里面禁掉的话，当刷新时，sessionID就会不断的变化，说明Cookie里面没有保存Session。)
（2）登陆邮箱的例子来理解session：登陆的页面和读邮件的页面是两个页面，那么读邮件的页面怎么知道这是你的邮件呢？那只有一个办法，你在登陆完成这个页面（登陆的页面）之后，他给你一个sessionId，你再访问后面的页面时，每次把这个sessionID带上，他就知道原来是你登陆进来的。
当你在访问大公司的页面时，比如新浪邮箱，你如果把浏览器的Cookie禁用了，登陆的时候sessionID就存不进去了，新浪邮箱又没有设置encodeURL，所以只能重新设置Cookies。
（3）在tomcat默认conf目录下面webapp默认的设置session的过期时间是30分，也就是说超过30分session就不能用了。对所有的webapp都适用，你可以通过下面这段代码设置。<session-config> <session-timeout>30</session-timeout></session-config>
（4）两个窗口的sessionID号永远不可能相等，除非一个窗口是另一个页面的子窗口。
Servlet跳转：
1.客户端跳转：在Servlet中要想进行客户端跳转，（地址栏会发生变化）直接使用HttpServletResponse接口的sendRedirect()方法即可。（但是要注意的是，此跳转只能传递session范围的属性，而无法传递request范围的属性，这是因为request属性范围只有在服务器端跳转中才可以使用）。
2.服务器端跳转：在Servlet中没有像JSP中的<jsp:forward>指令，所以如果要想执行服务器端跳转，就必须依靠RequestDispatcher接口完成。
提供两方法：forword()和include()可完成跳转实现。
但是还不够：如果要想使用此接口还要使用ServletRequest接口进行方法的实例化。
ServletRequest接口进行方法的实例化:Public RequestDispatcher getRequestDispatcher(String path){}
服务器端跳转之后，页面路径不会发生改变，而且此时可以在跳转后的JSP文件中接收到session及request范围的属性。
Web开发模式:
MVC设计模式：（Model-view-Controller）:都是以Servlet为主体展开的，由Servlet接收所有的客户端请求，然后根据请求调用相应的JavaBean，并将所有的显示结果交给JSP，也俗称MVC设计模式。
它强制的使应用程序的输入、处理和输出分开。
分为三个层次：
1.显示层（View）：主要负责接收Servlet传递的内容，并且调用javaBean，将内容显示给用户。
2.控制层：（Controller）主要负责所有的用户请求参数，判断请求参数是否合法，根据请求的类型调用javaBean执行操作并将最终的处理结果交由显示层进行显示。
3.模型层：（Model）完成一个独立的业务操作组件，一般都是以javabean或者ＥＪＢ的形式显示的。
在MVC模式中，最关键的部分是使用RequestDispatcher接口，因为内容都是通过此接口保存到JSP页面上的。
Servlet的特点：可以接收用户的请求参数，还可以调用java程序，所以肯定比JSP的性能高很多，而且安全性很高。最终所有操作的内容就要交给JSP进行显示了，这样一来servlet不方便输出的缺点就避免了。
Javabean负责完成单个的功能，jsp负责显示的功能，而Servlet负责连接jsp+javabean.Jsp->servlet->javabean开发。这种设计非常适合大型项目的开发，而且维护比较方便。美工和程序员就不会再扯皮了。
二．MVC模式清单：
1.数据库脚本创建。
2.DAO层主要是完成数据层的操作。
3.建立LoginServlet的Servelet
在servlet中，首先接收userid和userpass两个参数进行验证，如果没有输入参数，或者输入的参数为空，则会在info对象当中增加相应的错误信息。当验证通过后，程序将调用DAO进行数据库的验证，并根据DAO的返回结果来确定返回给客户端的信息。
4.JSP页面应该包含如下代码：
（1）接收属性：接收从Servlet传递过来的属性
（2）判断语句：判断到JSP中的属性是否存在
（3）输出内容：使用迭代或者是VO进行输出。
（4）一定要记住一点，在JSP页面中唯一运出导入的包只能是java.util包，只要把握住这几点就能开发出一个简洁、清晰的JSP页面。
过滤器
JSP完成的功能Servlet都能完成，但是Servlet具备很多JSP所不具有的，从使用上看可以分为三种：简单Servlet、过滤Servlet和监听Servlet
1.过滤器：是以一种组件的形式绑定在web应用程序当中的，与其他的Web应用程序组件不同的是，过滤器是采用链的方式进行处理的。一旦加入过滤器，所有的请求先交给过滤器处理，然后再访问相应的web资源的访问限制。
（1）实现过滤器：如果定义一个过滤器，则直接让一个类实现javax.servlet.Filter接口即可。
Public void init(FilterConfig filterConfig)Throws ServletException
public void doFilter(ServletRequest request,Servlet response,FilterChain chain)
实现具体的过滤操作，然后通过FilterChain让请求继续向下传递。chain.doFilter(request,response);
过滤器的销毁 public void destroy（）
2.过滤器的应用：
实例一：编码过滤器EncodingFilter.java
为所有页面设置统一的编码：如果按照之前的做法，在每一个JSP或者Servlet中都重复编写request.setCharacterEncoding("GBK")的语句肯定是不可取的，会造成大量的代码重复。
<!-- 编码过滤 -->
方法1：
在web.xml中配置：
<filter>
<filter-name>encoding</filter-name> <filter-class>org.ecjtu.lp.EncodingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
在servlet中写：
public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {
request.setCharacterEncoding("GB18030");
response.setCharacterEncoding("GB18030");
chain.doFilter(request, response);
}
方法2：
<!-- 编码过滤 -->
<filter>
<filter-name>encoding</filter-name>
<filter-class>org.ecjtu.lp.EncodingFilter </filter-class>
<init-param>
<param-name>charset</param-name>
<param-value>GB18030</param-value>
</init-param>
</filter>
public void init(FilterConfig config) throws ServletException {
// TODO Auto-generated method stub
this.charSet=config.getInitParameter("charset");//取得初始化参数
}
(2)登陆验证：最早的做法是通过session的方式完成，但是每个页面都这样的话，则肯定造成大量代码的重复，而通过过滤器的方法即可避免这种重复操作。
注意：向下转型：将ServletRequest转为HttpServletRequest。
总结：过滤器属于自动执行的一种servlet，过滤器依然需要在web.xml文件中进行配置。过滤器常用的功能是可以完成常用的编码过滤，及登录验证。
监听器
1.第三种servlet程序称为监听servlet，主要功能负责Web的各种操作，当相关的事件触发后将产生事件并对此事和request三种操作进行监听。
2.实例：监听器：在线人员统计
Session销毁的操作：
当一个新用户打开一个动态页时，服务器会为新用户分配session，并触发HttpsessionLisener接口中的sessionCreate()事件，但是在用户销毁时时却有两种不同的方式触发sessionDestroy（）事件。
方式一：调用HttpSession接口中的invalidate()方法，让一个session失效。
方式二：超过了配置session的超时时间，session超时时间可以直接在项目中的web.xml中配置。
<session-config>
<session-timeout>5</session-timeout>
<session_config>
默认的超时时间为30分钟。
Tomcat数据源：
传统JDBC的使用步骤存在以下四个步骤：
1加载数据库驱动程序：
2 通过DriverManager类取得数据库的连接对象。
3.通过Connection实例化PreparedStatement对象，编写SQL命令操作数据库。
4.数据库属于资源操作，操作完成后要关闭数据库以释放资源。
对于不同的用户只有操作不同，但是对于1,2,4三个步骤很明显是一个重复的操作。
如果开发中直接使用JDBC操作的话，那么就会产生这种性能问题，那么怎么做才是最合适的呢？如果假设数据库不关闭，以后如果有新的用户使用的时候直接取一个已经有的连接的话。
在Tomcat中使用数据库连接池：
在web容器中，数据库的连接池都是通过数据源（javax.sql.DataSorce）访问的，即可以通过javax.sql.DataSorce类取得一个Connection对象，但是要想得到一个DataSorce对象需要使用JNDI进行查找。
原理图：
对Tomcat中的Servlet.xml文件进行配置：配置mysql的数据库连接池：
JNDI属于命名及目录查找接口，主要功能是用于进行查找的，查找对象。但是，现在的数据库连接池是需要在tomcat上完成配置的：
要修改servlet.xml文件才可以起作用：
配置mysql连接池：
<Context path="/text"docBase = "**" reloadable = "true">
<Resource name ="jdbc/text"
auth= "Container"
type = "javax.sql.DataSorce"
maxActive ="100"
maxIdle = "30"
maxWait = "10000"
username = "root"
password = "****"
driverClassName = "org.git.mm.Driver"
url = "jdbc:mysql://localhost:3306/text"/>
配置Oracle连接池：
<Context path="/text"docBase = "**" reloadable = "true">
<Resource name ="jdbc/text"
auth= "Container"
type = "javax.sql.DataSorce"
maxActive ="100"
maxIdle = "30"
maxWait = "10000"
username = "root"
password = "****"
driverClassName = "Oracle.jdbc.driver.OracleDriver"
url = "jdbc:Oracle:thin:@localhost:1521:text"/>
配置完server.xml之后需要在一个web项目中配置web.xml：指明数据源的名称：
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/text</res-ref-name>
<res-type>javax.sql.DataSorce<res-type>
<res-auth>Container</res-auth>
</resouce-ref>
查找数据源：
数据源的操作使用的是JNDL方式进行查找的，所以使用数据源取数据库的连接
必须按照如下步骤进行：
（1） 初始化名称查找上下文：Context ctx = new InitialContext();
（2） 通过名称查找DataSource对象：Datasource ds = (DataSource)ctx.lookup(JNDL名称)；
（3） 通过DataSource取得一个数据库的连接：Connection conn = ds.getConnection();
JNDI服务(java Naming and Directory Interface,java命名及目录接口)是javaEE提供的一个服务，其服务的主要功能是通过一个名称的“key”查找到一个对象的value。
通过数据源取得数据库连接的代码：注意：在使用tomcat进行数据源查找时，java:comp/env（环境命名上下文Enviromnet Naming Context (ENC)）属性必须设置，对于一些高级的服务器可以不用设置（例如weblogic）。即下面的代码改为：String DSNAME = "java:comp/env/jdbc/mldn";//名称
如果取得连接，则会输出一个对象的信息：
在以后的开发中就可以直接将数据源应用到项目中了，只要数据源的名称不变，则数据库可以任意更换，提升了操作的性能。充分的体现了java的设计思想——可移植性。
数据源连接代码：
总结：
(1)通过数据库连接池可以提高数据库的操作性能，避免掉一些无用的操作。
(2)数据源使用时要使用JNDI进行查找，而且查找时需要指定“java:comp/env”的环境属性。
附：
使JDBC连接数据库：
package com.jd.jdbc1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class SelectDB
{
//驱动名(各个数据库不同)
static final String DRIVER = "com.mysql.jdbc.Driver";
//连接数据库的地址（各个版本的数据库不同）
static final String URL = "jdbc:mysql://localhost:3306/test";
//用户名
static final String USER = "root";
//密码
static final String PWD = "fendou";
/**
* 查询数据库
*/
public static void getAll()
{
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
//1、加载驱动
try
{
Class.forName(DRIVER);
//2、使用DrvierManager得到数据库的连接
conn = DriverManager.getConnection(URL, USER, PWD);
//3、创建发送SQL语句的对象
stmt = conn.createStatement();
//4、执行SQL语句
String sql = "select id,name,age from student";
//5、用ResultSet接收查询后的结果集
rs = stmt.executeQuery(sql);
//6、循环一条一条的取出结果集的记录
while(rs.next())//判断结果集是否有数据
{
//7、一列一列的取出数据(注意对应数据类型)
/*int id = rs.getInt(1);
String name = rs.getString(2);
int age = rs.getInt(3);*/
//一般情况都是写列名来获得该列的内容
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age");
System.out.println(id+","+name+","+age);
}
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
catch (SQLException e)
{
e.printStackTrace();
}
finally
{
try
{
if(rs != null)
{
//5、关闭rs
rs.close();
}
if(stmt != null)
{
//5、关闭stmt
stmt.close();
}
if(conn != null)
{
//6、关闭连接
conn.close();
}
}
catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String[] args)
{
getAll();
}
}
package com.jd.jdbc1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class TestConn
{
//驱动名(各个数据库不同)
static final String DRIVER = "com.mysql.jdbc.Driver";
//连接数据库的地址（各个版本的数据库不同）
static final String URL = "jdbc:mysql://localhost:3306/test";
//用户名
static final String USER = "root";
//密码
static final String PWD = "fendou";
//得到连接数据库的方法
public static void getConn()
{
Connection conn = null;
//1、加载驱动
try
{
Class.forName(DRIVER);
//2、使用DrvierManager得到数据库的连接
conn = DriverManager.getConnection(URL, USER, PWD);
//3、打印conn看其是否为null
System.out.println(conn);
}
catch (ClassNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try
{
if(conn != null)
{
//4、关闭连接
conn.close();
}
}
catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String[] args)
{
getConn();
}
}
package com.jd.jdbc1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class TestConn
{
//驱动名(各个数据库不同)
static final String DRIVER = "com.mysql.jdbc.Driver";
//连接数据库的地址（各个版本的数据库不同）
static final String URL = "jdbc:mysql://localhost:3306/test";
//用户名
static final String USER = "root";
//密码
static final String PWD = "fendou";
//得到连接数据库的方法
public static void getConn()
{
Connection conn = null;
//1、加载驱动
try
{
Class.forName(DRIVER);
//2、使用DrvierManager得到数据库的连接
conn = DriverManager.getConnection(URL, USER, PWD);
//3、打印conn看其是否为null
System.out.println(conn);
}
catch (ClassNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try
{
if(conn != null)
{
//4、关闭连接
conn.close();
}
}
catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String[] args)
{
getConn();
}
}
package com.jd.jdbc1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
*
* @author Administrator
*对数据库进行添加、删除、修改
*/
public class UpdateDB
{
//驱动名(各个数据库不同)
static final String DRIVER = "com.mysql.jdbc.Driver";
//连接数据库的地址（各个版本的数据库不同）
static final String URL = "jdbc:mysql://localhost:3306/test";
//用户名
static final String USER = "root";
//密码
static final String PWD = "fendou";
//添加记录
public static void add()
{
Connection conn = null;
Statement stmt = null;
//1、加载驱动
try
{
Class.forName(DRIVER);
//2、使用DrvierManager得到数据库的连接
conn = DriverManager.getConnection(URL, USER, PWD);
//3、创建发送SQL语句的对象
stmt = conn.createStatement();
//4、执行SQL语句
int rows = stmt.executeUpdate("insert into student values(null,'lisi',23)");
if(rows > 0)
{
System.out.println("操作成功");
}
else
{
System.out.println("操作失败");
}
}
catch (ClassNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try
{
if(stmt != null)
{
//5、关闭stmt
stmt.close();
}
if(conn != null)
{
//6、关闭连接
conn.close();
}
}
catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//添加记录
public static void delete()
{
Connection conn = null;
Statement stmt = null;
//1、加载驱动
try
{
Class.forName(DRIVER);
//2、使用DrvierManager得到数据库的连接
conn = DriverManager.getConnection(URL, USER, PWD);
//3、创建发送SQL语句的对象
stmt = conn.createStatement();
//4、执行SQL语句
String sql = "delete from student where id=1";
int rows = stmt.executeUpdate(sql);
if(rows > 0)
{
System.out.println("操作成功");
}
else
{
System.out.println("操作失败");
}
}
catch (ClassNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try
{
if(stmt != null)
{
//5、关闭stmt
stmt.close();
}
if(conn != null)
{
//6、关闭连接
conn.close();
}
}
catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//添加记录
public static void update()
{
Connection conn = null;
Statement stmt = null;
//1、加载驱动
try
{
Class.forName(DRIVER);
//2、使用DrvierManager得到数据库的连接
conn = DriverManager.getConnection(URL, USER, PWD);
//3、创建发送SQL语句的对象
stmt = conn.createStatement();
//4、执行SQL语句
String sql = "update student set age=44 where id=3";
int rows = stmt.executeUpdate(sql);
if(rows > 0)
{
System.out.println("操作成功");
}
else
{
System.out.println("操作失败");
}
}
catch (ClassNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try
{
if(stmt != null)
{
//5、关闭stmt
stmt.close();
}
if(conn != null)
{
//6、关闭连接
conn.close();
}
}
catch (SQLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String[] args)
{
add();
//delete();
//update();
}
}