小菜鸟之servlet

  1 # Servlet课程-1和2和3
  2 
容
  4 
  5 Web项目
  6     项目代码部署在服务器上，
  7     一般分为c\s（客户端\服务器端）和b\s（浏览器/服务器）
  8  服务器
  9     常用的服务器（tomcat服务器）
 10     tomcat的目录结构
 11         bin tomcat脚本
 12         conf 配置文件
 13         lib  一些依赖的包
 14         logs  日志文件
 15         webapps  部署的项目
 16         work    部署的项目java转成.class 文件
 17     项目部署到服务器上
 18         maven项目finance1103部署到服务器tomcat
 19 Maven项目的创建好处
 20     maven项目帮助程序员对jar包进行统一管理管理，
 21     方便团队统一jar包的版本
 22     库的网站
 23         https://mvnrepository.com/
 24 
 25 MVC思想（构建项目）
 26     view视图层： 负责model层处理结果的响应，输出给用户
 27                         将处理结果返回给网民，让其知道
 28                         jsp的形式呈现给用户
 29     control控制器层 :负责请求的派发和处理，针对请求进行处理。
 30                         谁处理该请求？通过servlet类实现
 31 
 32 ```
 33 model模型层： 负责和数据库进行交互，根据制定的请求处理数据
 34                     对请求进行处理中
 35 ```
 36 
 37 JSP
 38   jsp  java server page 运行在服务端的程序，是由html中嵌套java代码形式实现的。
 39   1.声明该文件为jsp文件
 40    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 41   2.每次修改都要重新运行一下服务器,才能输出
 42   3.jsp的内置对象(系统帮忙创建好)
 43     out对象：向页面输出信息
 44     request:
 45     response
 46     session
 47     config
 48     application
 49     page
 50     pageContext
 51     exception
 52   4、简单的登陆功能实现步骤？
 53     1、编写jsp文件中的form表单
 54     2、web.xml中配置servlet和servlet-mapping标签
 55     3、创建servlet类，在类中doget方法中进行参数传递的处理
 56   5、get请求方式下，参数传递出现中文乱码解决方案
 57     第一种，通过字符转码的方式
 58         new String(user1.getBytes("ISO-8859-1"),"utf-8");
 59         缺点：每个参数都需要这样操作
 60     第二种，通过设置tomcat的server.xml文件，在69行，中添加 URIEncoding="utf-8"
 61             <Connector port="8080" protocol="HTTP/1.1"
 62                        connectionTimeout="20000"
 63                        redirectPort="8443" />
 64          优点：所有参数一次性设置
 65   6、post请求下，参数传递出现中文乱码解决方案
 66                 request.setCharacterEncoding("utf-8");
 67                 response.setCharacterEncoding("utf-8");
 68   7、如何不分post和get请求进行中文乱码的处理？
 69      通过过滤器的方式实现
 70         1、创建过滤器，在doFilter方法中编写
 71                     request.setCharacterEncoding("utf-8");
 72                     chain.doFilter(request, response);
 73                     response.setCharacterEncoding("utf-8");
 74         2、在web.xml文件中，编写filter和filter-mapping标签
 75                     <filter>
 76                         <filter-name>CharacterEncoding</filter-name>
 77                         <filter-class>com.baidu.filter.CharacterEncodingFilter</filter-class>
 78                     </filter>
 79                     <filter-mapping>
 80                         <filter-name>CharacterEncoding</filter-name>
 81                         <!--/* 表示url项目名下所有的字段都需要经过此过滤器-->
 82                         <url-pattern>/*</url-pattern>
 83                     </filter-mapping>
 84   8、如何servlet中的验证结果信息返回到页面上？
 85             //响应的时候出现中文乱码的处理方式
 86             response.setCharacterEncoding("utf-8");
 87             response.setHeader("Content-Type", "text/html;charset=UTF-8");
 88              response.setContentType("text/html;charset=UTF-8");
 89             PrintWriter writer=response.getWriter();
 90              writer.print("该用户存在");
 91   9、从servlet类跳转到jsp文件？
 92         //请求转发:将请求转发出去
 93         request.getRequestDispatcher("jsp/success.jsp").forward(request,response);
 94         注意点：url路径从webapp目录下开始
 95 
 96   10、将servlet中的提示信息,传递到jsp文件中？
 97        servlet中编写：
 98        request.setAttribute("success","来自servlet中提示：登陆成功");
 99        jsp中编写：
100        <%--将servlet中的提示信息传递到jsp文件中--%>
101        <%
102            String success1 = (String)request.getAttribute("success");
103            out.print(success1);
104        %>
105        简写方式：
106            ·在web.xml中检查webapp标签是否含有如下属性
107                 <web-app
108                         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
109                         xmlns="http://java.sun.com/xml/ns/javaee"
110                         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
111                         id="WebApp_ID" version="3.0"
112                 >
113            ·在jsp中编写
114                   ${success}
115 
116 11、通过响应重定向方式从servlet类跳转到jsp文件
117       response.sendRedirect(request.getContextPath()+"/jsp/success.jsp");
118 12、请求转发和响应重定向2种方式的区别
119     ·请求转发方式url是原来的url，响应重定向方式的url是重新定向的url（新的url）
120     ·通过setAttribute()方法保存在request容器中的key-value不能实现传递
121 13、request\session\application\page等对象是一个容器?
122     request：setAttribute方法  key-value success  登陆成功
123             作用域和生命周期是一次请求：
124             请求转发是一次请求；甲-》乙-》丙
125             响应重定向是2次请求；甲-》乙
126                                  甲-》丙
127     session：作用域和生命周期：一次会话（多次请求，肯定超过2次）
128             setAttribute（） setAttribute（）；
129              HttpSession session = request.getSession();
130               session.setAttribute("success","来自servlet中提示：登陆成功");
131               session.getAttribute("success");
132      session是一次会话，多次请求？？
133             自然生命周期：两次请求的时间间隔在30分钟之内，session中的key-value一直有效；
134      人工方式使session中数据失效
135             session.invalidate(): 是session容器中的所有key-value 数据失效；应用场景：退出功能的实现
136             session.removeAttribute(key):是session容器中的某key对应的数据失效；
137 
138 174 
175 
176 # Servlet课程-4
177 
178 ## 九大内置对象
179 
180 | 名称        | 功能           | 类型                                | 作用域             |
181 | ----------- | -------------- | ----------------------------------- | ------------------ |
182 | request     | 请求对象       | 类型 javax.servlet.ServletRequest   | 作用域 Request     |
183 | response    | 响应对象       | 类型 javax.servlet.SrvletResponse   | 作用域 Page        |
184 | pageContext | 页面上下文对象 | 类型 javax.servlet.jsp.PageContext  | 作用域 Page        |
185 | session     | 会话对象       | 类型 javax.servlet.http.HttpSession | 作用域 Session     |
186 | application | 应用程序对象   | 类型 javax.servlet.ServletContext   | 作用域 Application |
187 | out         | 输出对象       | 类型 javax.servlet.jsp.JspWriter    | 作用域 Page        |
188 | config      | 配置对象       | 类型 javax.servlet.ServletConfig    | 作用域 Page        |
189 | page        | 页面对象       | 类型 javax.lang.Object              | 作用域 Page        |
190 | exception   | 例外对象       | 类型 javax.lang.Throwable           | 作用域 page        |
191 
192 ## request常用的方法
193 
194 getContextPath()
195 
196 getParameter()
197 
198 getParameters()
199 
200 setAttribute()
201 
202 getAttribute()
203 
204 setCharacterCoding()
205 
206 getRequestDispatcher()
207 
208 ## response常用的方法
209 
210 sendRedirect()
211 
212 setCharacterEncoding()
213 
214 setHeader()
215 
216 ## session常用的方法
217 
218 set Attribute(key,value)
219 
220 getAttribue（key）
221 
222 removeAttribute(key)
223 
224 invalidate()
225 
226 getMaxInactiveInterval()
227 
228 ## session和cookie之间的区别
229 
230 · session是容器，在服务器端创建，并保存在服务器
231 
232 · cookie也是一个容器，在服务器端创建，保存在客户端/浏览器
233 
234 · cookie中的数据在浏览器之间是不共享的，session中保存的数据在不同浏览器中可以共享访问
235 
236 · 从安全性角度来看，session更安全
237 
238 ## cookie的使用实现用户名保存
239 
240 **思路**
241 
242 1、在Servlet中创建cookie实例
243 
244 2、设置路径
245 
246 3、设置cookie的失效时间
247 
248 4、将cookie发送到浏览器
249 
250 5、在jsp文件中接受cookie
251 
252 6、在指定位置输出cookie中保存的value值
253 
254 **实现**
255 
256 1、servlet类中
257 
258 ```java
259                 //登陆成功，使用cookie将huangwei保存进来
260                 Cookie cookie=new Cookie("username","huangwei");
261                 //设置路径
262                 cookie.setPath("/");
263                 //设置cookie的过期时间
264               //  cookie.setMaxAge(0);//不记录，此cookie是不起作用的，无效
265               //  cookie.setMaxAge(-1);//会话级cookie，关闭浏览器就消失，保存在内存中
266                 //持久化cookie，以文件的形式保存在硬盘里,时间可以自定义，单位秒
267                 cookie.setMaxAge(60*60);//持久化1小时
268                 //发送到浏览器中
269                 response.addCookie(cookie);
270 ```
271 
272 2、jsp中
273 
274 ```java
275 <%--java脚本--%>
276 <%
277     String username="";
278  //取到存放在cookie中的值
279     Cookie[] cookies = request.getCookies();
280     //进行非空判断
281     if(cookies!=null && cookies.length!=0){
282         // 遍历数组
283         for(Cookie c:cookies){
284             if(c.getName().equals("userCookie")){
285                 username = c.getValue();
286             }else {
287                 System.out.println("cookie的name值不等于userCookie");
288             }
289         }
290     }else{
291         System.out.println("数组为空");
292     }
293 
294 %>
295 <form method="post" action="<%=request.getContextPath() %>/nankeyuan">
296     姓名：<input type="text" name="xiaogou" value="huangwei ">
297     密码：<input type="password" name="xiaomao" value="">
298     ............
299     <input type="submit" value="登陆">
300 </form>
301 
302 ```
303 
304 ## Cookie的生命周期
305 
306 Cookie不只有name和value两个属性
307 
308 - Cookie的maxAge（掌握）：Cookie的最大生命，即Cookie可保存的最大时长。以秒为单位. 例如：cookie.setMaxAge(60)表示这个Cookie会被浏览器保存到硬盘缓存上60秒
309 
310   - maxAge>0：浏览器会把Cookie保存到客户机硬盘上，有效时长为maxAge的值决定。
311   - maxAge<0：Cookie只在浏览器内存中存在，当用户关闭浏览器时，浏览器进程结束，同时Cookie也就死亡了.
312 
313 - maxAge=0：浏览器会马上删除这个Cookie！
314 
315 
316 
317 ## Application
318 
319   application表示的整个项目，也是一个容器，放在服务器中。
320 
321   application对象由多个客户端用户共享，它的应用范围是所有的客户，服务器启动后，新建一个application对象，该对象一旦建立，就一直保持到服务器关闭。当有客户访问服务器上的一个JSP页面时，JSP引擎为该客户分配已建立的application对象；当客户在所访问站点的不同页面浏览时，其application是同一个，直到服务器关闭。
322 
323 ## 统计页面被访问次数
324 
325 ```java
326   <%--java 脚本--%>
327   <%
328       //key-value 对应 key是总数代号，value表示总数  count-100 count-1  count-0
329       Object count = application.getAttribute("count");
330       if(count ==null){
331           application.setAttribute("count",1);
332       }else{
333           application.setAttribute("count",(int)count+1);
334       }
335       int count1 = (int)application.getAttribute("count");
336       System.out.println("该页面被访问"+count1);
337       out.print("该页面被访问"+count1);
338   %>
339 ```
340 
341 ## servlet
342 
343   在mvc思想中servlet类充当与哪一层？
344 
345   **补充**
346 
347   m：model模型层，负责业务逻辑处理和数据库的交互。通过创建service包实现业务逻辑        的处理。通过常见dao包实现数据库的交互。
348 
349   v: view 视图层 ，负责 向用户展示页面和表单的编写等，通过jsp文件实现的
350 
351   c: controller  控制器层，负责请求的派发和处理等，通过servlet文件实现
352 
353   servlet类，充当controller控制器层，是运行在服务器端的程序，相当于一个容器。也具有生命周期。
354 
355   **运行原理**
356 
357   <img src="C:\Users\ww\Desktop\南科院-web-1108\images\wps90AB.tmp.jpg" alt="img" style="zoom:33%;" />
358 
359   **Servlet类的创建**
360 
361   通过继承HttpServlet接口实现Servlet类的创建。
362 
363   **生命周期**
364 
365   init() 初始化，启动服务器后，先执行init（）方法，只初始化执行一次。
366 
367   service（）提供服务，对请求方式的处理过程。每请求1次，该方法执行一次。
368 
369   destory（）销毁死亡，只有在服务器停止的时候才执行。
370 
371 387 ## mySql学习
388 
389 ```mysql
390 #  数据库  表   表中记录
391 #查询数据库
392 SHOW DATABASES;
393 #创建数据库
394 CREATE DATABASE	school;
395 #不修改
396 #删除
397 DROP DATABASE school;
398 #制定选择某数据库
399 USE school;
400 #####################
401 #创建表
402 CREATE TABLE student(
403 `id` INT(10) PRIMARY KEY AUTO_INCREMENT COMMENT '编号id',
404 `name`VARCHAR(40) COMMENT'学生姓名',
405 `studentNo` INT(10) COMMENT'学号',
406 `birthday` DATETIME COMMENT'生日',
407 `createdBy` INT(10) COMMENT'创建人',
408 `creationDate` DATETIME COMMENT'创建时间',
409 `modifyBy` INT(10) COMMENT'修改人',
410 `modifyDate` DATETIME COMMENT'修改时间'
411 );
412 #查询表
413 SHOW TABLES;
414 DESCRIBE student1;
415 #删除表
416 DROP TABLE student1;
417 #修改表
418 #1、修改表的名字
419 ALTER TABLE student RENAME student1;
420 #2、添加字段
421 ALTER TABLE student1 ADD sex VARCHAR(2);
422 #3、删除字段
423 ALTER TABLE student1 DROP sex;
424 #4、sex改成gender
425 ALTER TABLE student1 CHANGE sex gender VARCHAR(10);
426 #################################
427 #处理表中的记录
428 #添加数据
429 INSERT INTO student1(
430 id,`name`,studentNo,
431 birthday,createdBy,
432 creationDate,modifyBy,modifyDate,gender
433 )VALUES
434 ('1','张三1','1','2019-1-1',
435 '1','2019-11-8','1','2019-11-8','男'),
436 ('2','张三2','1','2019-1-1',
437 '1','2019-11-8','1','2019-11-8','男'),
438 ('3','张三3','1','2019-1-1',
439 '1','2019-11-8','1','2019-11-8','男'),
440 ('4','张三4','1','2019-1-1',
441 '1','2019-11-8','1','2019-11-8','男')
442 ;
443 #查询表中记录
444 SELECT * FROM student1;
445 SELECT * FROM student1 WHERE id=1;
446 #删除表中记录
447 DELETE FROM student1 WHERE id=4;
448 DELETE FROM student1;
449 #修改某一个字段的赋值
450 UPDATE student1 SET `name`='李四' WHERE id=1;
451 
452 
453 ```
454 
455 
456 
457 499 # Servlet课程-5
500 
501 ## 如何使MySQL和Java连接
502 
503 ### **jdbc技术**
504 
505 Java database connection ：Java和数据库连接技术,实现对数据库的增删改查功能（交互）。
506 
507 数据库是一个服务器，连接服务器需要知道：url 、用户名、密码、驱动加载。
508 
509 ### 准备工作
510 
511 1、创建util包，util工具包，存放工具性质的类。
512 
513 <img src="C:\Users\ww\Desktop\南科院-web-1108\images\1573259997992.png" alt="1573259997992" style="zoom:50%;" />
514 
515 2、在util中创建JdbcUtil类，该类中编写和数据库进行交互的方法。
516 
517 3、需要驱动，该驱动来源一个依赖jar包：mysql-connector-java.jar
518 
519 ```java
520     <dependency>
521       <groupId>mysql</groupId>
522       <artifactId>mysql-connector-java</artifactId>
523       <version>8.0.18</version>
524     </dependency>
525 ```
526 
527 <img src="C:\Users\ww\Desktop\南科院-web-1108\images\1573260450582.png" alt="1573260450582" style="zoom:80%;" />
528 
529 ### 编写连接数据库方法
530 
531 ```java
532     //连接数据库mysql :url 用户名 密码  驱动
533     public boolean getConnection(){
534 
535         try {
536             //添加驱动
537             Class.forName("com.mysql.jdbc.Driver");
538             //编写url路径 jdbc:mysql://localhost:3306/数据库名
539             String url="jdbc:mysql://localhost:3306/school?serverTimezone=UTC&useUnicode=true$characterEncoding=utf8";
540 
541             //获得connection数据库连接器
542             connection = DriverManager.getConnection(url, "root", "root");
543 
544         } catch (Exception e) {
545             e.printStackTrace();
546         }
547         return true;
548     }
549 ```
550 
551 ### 编写增删改方法
552 
553 ```java
554 //增删改功能
555     public int executeUpdate(String sql,Object[] params){
556         int updateRows=0;
557         try {
558             if (this.getConnection()){
559                 //获得预编译对象,提高查询速度
560                 preparedStatement = connection.prepareStatement(sql);
561 
562                 //遍历params数组,将占位符中填充数组中的元素
563                 for(int i=0;i<params.length;i++){
564                     preparedStatement.setObject(i+1,params[i]);
565                 }
566                 //执行增删改功能,返回值大于0，表示 执行成功
567                 updateRows= preparedStatement.executeUpdate();
568 
569             }
570         } catch (Exception e) {
571             e.printStackTrace();
572         }
573         return updateRows;
574     }
575 
576 ```
577 
578 **思路**
579 
580 ```java
581 **     1  在sql客户端编写的增加sql语句
582      * INSERT INTO student1(
583      * id,
584      * `name`,studentNo,birthday,createdBy,creationDate,
585      * modifyBy,modifyDate
586      *
587      *
588      * )VALUES(
589      * 5,'王五','5','2019-11-11','2','2011-1-1','2','2011-1-1'
590      * );
591      *2-1  在java类中编写
592      * 在java的sql表现形式  String sql=
593      * INSERT INTO student1(
594      * id,
595      * `name`,studentNo,birthday,createdBy,creationDate,
596      * modifyBy,modifyDate
597      *
598      * )VALUES(
599      * ？,？,？,？,？,？,？,？
600      * );
601     *  2-2  String sql=INSERT INTO student1(id,`name`,studentNo,birthday,createdBy,creationDate,modifyBy,modifyDate)VALUES(？,？,？,？,？,？,？,？);
602     *  2-3  Object[] params 是一个数组，
603      *    Object[] params={5,'王五','5','2019-11-11','2','2011-1-1','2','2011-1-1'}；
604      *
605      * */
606         3  将占位符？中填充数组中的数组元素
607 
608 ```
609 
610 ### 编写查询功能
611 
612 ```java
613 //查询功能（全部查询和条件查询）
614     public ResultSet executeQuery(String sql,Object[] params){
615 
616         try{
617             //获得预编译对象
618             if(this.getConnection()){
619                 preparedStatement = connection.prepareStatement(sql);
620             }
621 
622             if(params!=null){
623                 //将占位符填充数组元素
624                 for (int i=0;i<params.length;i++){
625                     preparedStatement.setObject(i+1,params[i]);
626                 }
627             }
628             //执行查询功能
629           resultSet = preparedStatement.executeQuery();
630 
631         }catch (Exception e){
632             e.printStackTrace();
633         }
634         return resultSet;
635     }
636 ```
637 
638 ### 关闭资源
639 
640 ```java
641 //关闭资源
642     public boolean closeResource(){
643 
644         try{
645             //关闭resultSet
646             if(resultSet!=null){
647                 resultSet.close();
648             }
649             //关闭preparedStatement
650             if(preparedStatement!=null){
651                 preparedStatement.close();
652             }
653             //关闭connection
654             if(connection!=null){
655                 connection.close();
656             }
657 
658         }catch (Exception e){
659             e.printStackTrace();
660         }
661 
662         return true;
663     }
664 
665 ```
666 
667 ### 使用junit测试
668 
669 #### 1、添加junit依赖（jar）
670 
671 ```
672 <dependency>
673       <groupId>junit</groupId>
674       <artifactId>junit</artifactId>
675       <version>4.11</version>
676       <scope>test</scope>//将此句删除
677     </dependency>
678 ```
679 
680 
681 
682 #### 2、创建test包，包内创建测试类
683 
684 <img src="C:\Users\ww\Desktop\南科院-web-1108\images\1573267253146.png" alt="1573267253146" style="zoom:67%;" />
685 
686 
687 
688 #### 3、进行测试
689 
690 ##### **查询所有记录**
691 
692 ```java
693 @Test
694     public void test1(){
695         //查询表中的所有数据记录
696         String sql="select * from student1";
697         //Object[] params=null;
698         ResultSet resultSet = jdbcUtil.executeQuery(sql, null);
699         try{
700             while(resultSet.next()){
701                 //获得记录中的列信息
702                 int  idValue = (int)resultSet.getObject(1);
703                 String nameValue= (String) resultSet.getObject(2);
704                 //int studentNo=(int)resultSet.getObject(3);
705                 int studentNoValue=resultSet.getInt(3);
706                 Date birthdayValue=resultSet.getDate(4);
707                 int createdByValue=(int)resultSet.getObject(5);
708                 Date creationDateValue=resultSet.getDate(6);
709                 int modifyByValue=resultSet.getInt(7);
710                 Date modifyDateValue=resultSet.getDate(8);
711                 String genderValue=resultSet.getString(9);
712                 System.out.println(idValue+nameValue+studentNoValue+
713                         birthdayValue+createdByValue+creationDateValue+
714                         modifyByValue+modifyDateValue+genderValue);
715             }
716         }catch (Exception e){
717 				e.printStackTrace();
718         }
719 		//关闭资源
720         jdbcUtil.closeResource();
721     }
722 ```
723 
724 ##### **查询某个id对应的记录**
725 
726 ```java
727 //查询某个id对应的数据记录
728     @Test
729     public void test2(){
730         String sql="select * from student1 where id=?";
731         Object[] params={2};
732         ResultSet resultSet = jdbcUtil.executeQuery(sql, params);
733         try{
734             while(resultSet.next()){
735                 //获得记录中的列信息
736                 //int  idValue = (int)resultSet.getObject(1);
737                 int idValue=resultSet.getInt("id");
738 
739                 //String nameValue= (String) resultSet.getObject(2);
740                 String nameValue=resultSet.getString("name");
741 
742                // int studentNoValue=resultSet.getInt(3);
743                 int studentNoValue=resultSet.getInt("studentNo");
744 
745                // Date birthdayValue=resultSet.getDate(4);
746                 Date birthdayValue=resultSet.getDate("birthday");
747 
748                // int createdByValue=(int)resultSet.getObject(5);
749                 int createdByValue=(int)resultSet.getObject("createdBy");
750 
751                 //Date creationDateValue=resultSet.getDate(6);
752                 Date creationDateValue=resultSet.getDate("creationDate");
753 
754                System.out.println(idValue+nameValue+studentNoValue+
755                         birthdayValue+createdByValue+creationDateValue);
756             }
757         }catch (Exception e){
758 				e.printStackTrace();
759         }
760         //关闭资源
761         jdbcUtil.closeResource();
762     }
763 ```
764 
765 ### 备份JdbcUtil工具类
766 
767 ```java
768 package com.baidu.util;
769 
770 import java.sql.*;
771 
772
775 public class JdbcUtil {
776     private Connection connection=null;
777     private PreparedStatement preparedStatement=null;
778     private ResultSet resultSet=null;
779 
780     //连接数据库mysql :url 用户名 密码  驱动
781     private boolean getConnection(){
782         try {
783             //添加驱动
784             Class.forName("com.mysql.jdbc.Driver");
785             //编写url路径 jdbc:mysql://localhost:3306/数据库名
786             String url="jdbc:mysql://localhost:3306/school?serverTimezone=UTC&useUnicode=true$characterEncoding=utf8";
787             //获得connection数据库连接器
788             connection = DriverManager.getConnection(url, "root", "root");
789 
790         } catch (Exception e) {
791             e.printStackTrace();
792         }
793         return true;
794     }
795 
796     //增删改功能
797     public int executeUpdate(String sql,Object[] params){
798         int updateRows=0;
799         try {
800             if (this.getConnection()){
801                 //获得预编译对象,提高查询速度
802                 preparedStatement = connection.prepareStatement(sql);
803 
804                 //遍历params数组,将占位符中填充数组中的元素
805                 for(int i=0;i<params.length;i++){
806                     preparedStatement.setObject(i+1,params[i]);
807                 }
808                 //执行增删改功能,返回值大于0，表示 执行成功
809                 updateRows= preparedStatement.executeUpdate();
810 
811             }
812         } catch (Exception e) {
813             e.printStackTrace();
814         }
815         return updateRows;
816     }
817 
818     //查询功能（全部查询和条件查询）
819     public ResultSet executeQuery(String sql,Object[] params){
820         try{
821             //获得预编译对象
822             if(this.getConnection()){
823                 preparedStatement = connection.prepareStatement(sql);
824             }
825             if(params!=null){
826                 //将占位符填充数组元素
827                 for (int i=0;i<params.length;i++){
828                     preparedStatement.setObject(i+1,params[i]);
829                 }
830             }
831             //执行查询功能
832             resultSet = preparedStatement.executeQuery();
833 
834         }catch (Exception e){
835             e.printStackTrace();
836         }
837         return resultSet;
838     }
839     //关闭资源
840     public boolean closeResource(){
841         try{
842             //关闭resultSet
843             if(resultSet!=null){
844                 resultSet.close();
845             }
846             //关闭preparedStatement
847             if(preparedStatement!=null){
848                 preparedStatement.close();
849             }
850             //关闭connection
851             if(connection!=null){
852                 connection.close();
853             }
854 
855         }catch (Exception e){
856             e.printStackTrace();
857         }
858         return true;
859     }
860 
861 }
862 
863 ```
864 
865874 
875 ##### 1、配置tomcat中context.xml文件
876 
877 配置Tomcat的conf/context.xml(将下面代码复制粘贴到context.xml中的context标签中)
878 
879 ```xml
880 <Resource name="jdbc/news"  881               auth="Container"  type="javax.sql.DataSource"  maxActive="100"  882               maxIdle="30" maxWait="10000" username="root"  password="root"  883               driverClassName="com.mysql.jdbc.Driver"  884               url="jdbc:mysql://127.0.0.1:3306/数据库名"/>
885 
886 ```
887 
888 ![1573282989441](C:\Users\ww\Desktop\南科院-web-1108\images\1573282989441.png)
889 
890 ##### 2、编写连接功能
891 
892 ```java
893 //通过连接池实现连接
894     public boolean getConnection1() {
895         try {
896             //初始化上下文
897             Context ct = new InitialContext();
898             //获取与逻辑名相关联的数据源对象
899             DataSource ds = (DataSource) ct.lookup("java:comp/env/jdbc/xiaogou");//为<Resource>中的name的值
900             cnt = ds.getConnection();
901         } catch (NamingException e) {
902             // TODO Auto-generated catch block
903             e.printStackTrace();
904         } catch (SQLException e) {
905             // TODO Auto-generated catch block
906             e.printStackTrace();
907         }
908         return true;
909 
910     }
911 ```
912 
913 ## 通过model层实现三层架构
914 
915 1、在项目中创建2个包：service包和dao包
916 
917 ​	service包：存放业务逻辑的处理代码
918 
919 ​	dao包：database access 存放连接数据库的代码
920 
921 <img src="C:\Users\ww\Desktop\南科院-web-1108\images\1573347905837.png" alt="1573347905837" style="zoom:67%;" />
922 
923 2、编写dao包中的代码
924 
925 ​		a 在此包中创建接口和实现类（注意：命名要规范）
926 
927 ​		<img src="C:\Users\ww\Desktop\南科院-web-1108\images\1573348188546.png" alt="1573348188546" style="zoom:50%;" />
928 
929 ​		b 在接口中编写登陆方法和在实现类中重写该登陆方法
930 
931 ```java
932 public interface UserDao {
933     //登陆方法
934     public ResultSet login(String username, String password);
935 }
936 ```
937 
938 ```java
939 public class UserDaoImpl implements UserDao {
940     @Override
941     public ResultSet login(String username, String password) {
942         //连接数据库
943         return null;
944     }
945 }
946 ```
947 
948 ​	c  连接数据库操作
949 
950 ```java
951 public class UserDaoImpl implements UserDao {
952 
953     ResultSet resultSet=null;
954     @Override
955     public ResultSet login(String username, String password) {
956         //连接数据库
957         JdbcUtil jdbcUtil = new JdbcUtil();
958         String sql="select count(*) as count from user where " +
959                 "username=? and password=?";
960         Object[] params={username,password};
961         resultSet = jdbcUtil.executeQuery(sql, params);
962         return resultSet;
963     }
964 }
965 ```
966 
967 d  在数据库中创建user表（school库中）
968 
969 ```sql
970 #选择制定库
971 USE school;
972 #在库中创建表
973 CREATE TABLE `user`(
974 id INT(4) PRIMARY KEY AUTO_INCREMENT COMMENT '编码id',
975 username VARCHAR(40) COMMENT '用户名',
976 `password` VARCHAR(40) COMMENT '用户密码'
977 );
978 #查询表结构
979 DESCRIBE USER;
980 #插入表记录2条
981 INSERT INTO `user`(id,username,`password`)
982 VALUES(1,'zhangsan','zhangsan'),(2,'lisi','lisi');
983 #查询表记录
984 SELECT * FROM `user`;
985 #测试是否存在某某人
986 SELECT COUNT(*) AS `count` FROM `user`
987 WHERE username='zhangsan' AND `password`='zhangsan'
988 ```
989 
990 3、在service包中编写代码
991 
992 a 创建接口和对应的实现类（UserService和UserServiceImpl）
993 
994 <img src="C:\Users\ww\Desktop\南科院-web-1108\images\1573350311295.png" alt="1573350311295" style="zoom:67%;" />
995 
996 b  编写接口和实现类中的代码
997 
998 ```java

1001  */
1002 public interface UserService {
1003     //登陆方法
1004     public boolean login(String username,String password);
1005 }
1006 ```
1007 
1008 ```java
1009
1012 public class UserServiceImpl implements UserService {
1013     //引用接口userDao
1014     public UserDao userDao=new UserDaoImpl();
1015     //登陆方法
1016     public boolean login(String username, String password) {
1017         //进行业务逻辑代码的编写
1018         ResultSet resultSet = userDao.login(username, password);
1019         boolean flag=false;
1020         if(resultSet!=null){
1021             flag=true;
1022         }
1023         return flag;
1024     }
1025 }
1026 ```
1027 
1028