JSTL、断点、JavaEE、DBUTils连接池

summarize

JSTL：在jsp页面上用标签去写if语句和for循环，jstl 出现目的和el一样，替代 jsp 页面上的脚本代码，JSTL有5个字库，目前常用核心库 Core库，其他4个库是jsp时代用，目的为了完成jsp上的增删改查。

在使用JSTL时，第一步引入<%@taglib%> 指令，每个页面都要导一次 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

域里面取集合注意：items一定要写el表达式. 编辑JSP页面用el表达式和JSTL标签遍历简单方便

找错误：根据文件来找错误 1.页面找错用f12找，例：jsp标签的错 2. Debug断点找错：

javaEE的开发模式：javaEE开发模式就是JavaWeb的开发模式，套路！model1模式：jsp+javaBean 弊端：混乱复杂。 model2：jsp+Servlet+javaBean ，Servlet：处理java，jsp：做页面

DBUtils:简化JDBC的，少些代码，apache commons组件一成员：DBUtils，它有三个核心功能

① QueryRunner 对SQL操作 ② ResultSetHandler 接口，定义select操作后，封装结果集。 ③ DbUtils类，是一个工具类，关闭资源与事务处理方法

连接池：在实际开发中，“获得连接”或“释放资源”非常消耗系统资源的两个过程，这时候我们采用连接池技术，提高程序执行效率和降低系统资源开销，共享Connection，这样就不需要每次创建、释放连接，这些操作都交给连接池。用池（pool）管理Connection，可以重复使用，当使用完后，调用的close方法不会真的关闭，Connection，而是把它归还池。

JSTL技术

1．JSTL概述

JSTL（JSP Standard Tag Library)，JSP标准标签库，可嵌入jsp页面中使用标签形式完成业务逻辑等功能，和el一样出现目的替代jsp页面中脚本代码，STL标准标签库有5个子库，JSTL标准标签库有5个子库，目前最常用核心库Core库，其他4个库都是jsp时代用，目的为了完成在jsp上完成增删改查，很麻烦。

2．JSTL下载与导入

JSTL下载：

从Apache的网站下载JSTL的JAR包。进入 “http://archive.apache.org/dist/jakarta/taglibs/standard/binaries/” 网址下载 JSTL的安装包。jakarta-taglibs-standard-1.1.2.zip，然后将下载好的JSTL安装包进行解压，此时，在lib目录下可以看到两个JAR文件，分别为jstl.jar和standard.jar。jstl.jar 包含JSTL规范中定义的接口和相关类，standard.jar 包含用于实现JSTL的.class文件以及JSTL中5个标签库描述符文件（TLD）

将两个jar包导入我们工程的lib中，使用jsp的taglib指令导入核心标签库

3．JSTL核心库的常用标签

1）<c:if test=””>标签：test是返回boolean的条件

1）<c:forEach>标签：使用方式有两种组合形式：

代码演示

<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@page import="java.util.ArrayList"%>
<%@page import="com.oracle.domain.User"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <%-- <c:if test="${1==1 }"><!-- 判断是否正确 判断时必须在大括号里面判断 -->
    正确
    </c:if>
    <c:if test="${1!=1 }"><!-- 用取反判断这是错误 相当于else -->
    错误
    </c:if> --%>
    <!-- 普通for -->
    <c:forEach begin="0" end="10" var="i">
        ${i }   <!-- 这里加上$会显示0到5，只写i，就会显示5个i -->
    </c:forEach>
    <%
        User user1=new User();
        user1.setAge(8);
        user1.setName("袁一鸣");
        User user2=new User();
        user2.setAge(10);
        user2.setName("胸大");
        ArrayList<User> list=new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        request.setAttribute("UserList",list);
        //创建Map <String,User
        Map<String,User> map=new HashMap<String,User>();
        map.put("1",user1);
        map.put("2",user2);
        //创建List<String>
        ArrayList<String> arr=new ArrayList<String>();
        arr.add("a");
        arr.add("b");
        session.setAttribute("str",arr);        
    %>
</body>
</html>

示例：

1）遍历List<String>的值

2）遍历List<User>的值

3）遍历Map<String,String>的值

4）遍历Map<String,User>的值

5）遍历Map<User,Map<String,User>>的值

entry.key-----User

entry.value------List<String,User>

导包注意：jsp里面导包时，在代码下划线后面 alt+/ 导包

先创建domain包创建实体类

package com.oracle.domain;
//创建一个class 并私有
public class User {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + "]";
    }
    
}

<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@page import="java.util.ArrayList"%>
<%@page import="com.oracle.domain.User"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>   
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<!-- 创建集合，并从域里面取出集合 -->
<%
/* 先向域里设置值 */
    User user1=new User();
    user1.setAge(8);
    user1.setName("袁一鸣");
    User user2=new User();
    user2.setAge(10);
    user2.setName("胸大");
    ArrayList<User> list=new ArrayList<User>();
    /* 将两个对象放入list集合 */
    list.add(user1);
    list.add(user2);
    request.setAttribute("UserList",list);
    /* 创建Map<String,User> */
    Map<String,User> map=new HashMap<String,User>();
    map.put("1",user1);
    map.put("2",user2);
    application.setAttribute("UserMap",map);
    /* 创建List<String> */
    ArrayList<String> arr=new ArrayList<String>();
    arr.add("a");
    arr.add("b");
    session.setAttribute("str",arr);
%> 
<!-- 从域里面取出集合 -->
<!-- 遍历ListString 类型 -->
    <!-- 现在学的增强for-->
    <!-- 增强for用items属性，items要跟el表达式搭配使用，item：声明遍历的容器名，var：变量名 -->
    <c:forEach items="${str }" var="s">
        ${s }
    </c:forEach>
    <!-- 之前学的增强for  这两个功能一样 -->
    <!-- for(String s:str){
        System.out.println(s);
    } -->
<!-- 遍历ListUser类型 -->
    <c:forEach items="${UserList}" var="user">
        ${user.name}...${user.age}
    </c:forEach>
    <!-- 以前学过的 增强for遍历USer -->
    <!-- for(User user:UserList){
        System.out.println(user.getName()+"..."+user.getAge())
    } -->
<!-- 遍历Map --><!-- entry就是map里的结婚证 -->
    <c:forEach items="${UserMap}" var="entry">
        ${entry.key}...${entry.value.name}...${entry.value.age}        
    </c:forEach>
</body>
</html>

注意：每个jsp页面都要引入一遍

遍历结果：

用el表达式和JSTL标签遍历 Shop

步骤：先把页面改成EL和JSTL 一块遍历

第一步：先导包，在jsp页面上引入 <%@ taglib%> 展示部分代码和效果

/* 增强for 循环遍历集合 */
        for(Product pro:list){
            out.write("<div class='col-md-2'>");
            out.write("<a href='product_info.htm'>");
            out.write("<img src='"+pro.getPimage()+"' "+
            "width='170' height='170' style='display: inline-block;'>");
            out.write("</a>");
            out.write("<p>");
            out.write("<a href='product_info.html'"
                    +"style='color: green'>"+pro.getPname()+"</a>");
            out.write("</p>");
            out.write("<p>");
            out.write("<font color='#FF0000'>商城价：&yen;"+pro.getMarket_price()+"</font>");
            out.write("</p>");
            out.write("</div>");
        }
%> --%>
<!-- 上面是老方法，麻烦，现在用forEach 来写增强for  -->
<c:forEach items="${ProductList}" var="pro">
    <div class="col-md-2" style="height:250px"><!-- 这里style设置布局 -->
            <a href="product_info.htm"> <img src="${pro.pimage }"
                width="170" height="170" style="display: inline-block;">
            </a>
            <p>
                <a href="product_info.html" style='color: green'>${pro.pname }</a>
            </p>
            <p>
                <font color="#FF0000">商城价：&yen;${pro.market_price }</font>
            </p>
        </div>
</c:forEach>

黄色代码就是用 </c:forEach>来替换以前的增强for.style="height:250px" 设置布局用的

找错误：

Debug断点找错：代码错误看后台，要看第一条，看什么异常，找到那一行，在错误代码的下一行根部，双击加断点,断点可以无数个，启动Debug模式运行，在server 右击找小爬虫，运行网页请求，这时会弹出询问框，“是否进入debug模式” 选yes。

当进入Debug模式时，会自动切换这里。然后就看

接下来看

断点上面一行是错误代码

跳到下一个断点一行一行循环执行Debug

取消断点

javaEE的开发模式

1．什么是模式模式在开发过程中总结出的“套路”，总结出的一套约定俗成的设计模式

2．javaEE经历的模式

model1模式：不推荐

技术组成：jsp+javaBean

model1的弊端：随着业务复杂性导致jsp页面比较混乱

model2模式

技术组成：jsp+servlet+javaBean

model2的优点：开发中使用各个技术擅长的方面

servlet：处理java业务代码

jsp：擅长页面的实现

MVC：---- web开发的设计模式

M：Model---模型 javaBean：封装数据

V：View-----视图 jsp：单纯进行页面的显示

C：Controller----控制器 Servelt：获取数据--对数据进行封装--传递数据-- 指派显示的jsp页面

3．javaEE的三层架构

服务器开发时分为三层

web层：与客户端交互

service层：复杂业务处理

dao层：与数据库进行交互

开发实践时三层架构通过包结构体现

MVC与JavaEE三层架构有什么关系？

总结：

EL表达式

从域中取出数据 ${域中存储的数据的name}

${pageContext.request.contextPath}

JSTL标签(核心库)

<%@ taglib uri=”” prefix=”c”%>

<c:if test=””>

<c:forEach items=”数组或集合” var=”数组或集合中的每一个元素”>

一、 DBUtils

利用DBUtils进一步简化JDBC数据库的增删改查的代码，同时利用从连接池中接取连接，进而进行简化和减少资源的消耗！

1.1 概述

DBUtils

1、JDBC简化开发工具包，需要导入 commons-dbutils-1.6.jar 工具包才能使用DBUtils工具

2、是java编程中的数据库操作实用工具，小巧简单实用

3、封装了对JDBC的操作，简化了JDBC，可以少写代码

Dbutils三个核心功能介绍

①、QueryRunner对sql语句操作的API.

②、ResultSetHandler接口，定义select操作后，封装结果集.

③、DbUtils类，是一个工具类,关闭资源与事务处理的方法

二 QueryRunner核心类

update(Connection conn, String sql, Object... params) ，表数据的增加、删除、更新（“Object....” 意思是可变参数，有返回值 int ）

query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，表查询

三 QueryRunner实现添加、更新、删除操作update

update的增删改展示代码：

// 新增
    public int addSort(Integer sid, String sname) throws SQLException {
        // 获取连接对象
//        Connection conn = JDBCUtils.getConn();
        // 创建QueryRunner对象
//        QueryRunner qr = new QueryRunner();
        QueryRunner qr = new QueryRunner(MyDBUtils.getDataSource());
        String sql = "insert into sort values(?,?)";
//        int row = qr.update(conn, sql, sid, sname);
        int row = qr.update(sql, sid, sname);
        return row;
    }

    // 修改
    public int updateSort(Integer sid, String sname) throws SQLException {
        // 获取连接对象
        Connection conn = JDBCUtils.getConn();
        // 创建QueryRunner对象
        QueryRunner qr = new QueryRunner();
        String sql = "update  sort set sname=? where sid=?";
        int row = qr.update(conn, sql, sname, sid);
        return row;
    }

    // 删除
    public int deleteSort(Integer sid) throws SQLException {
        // 获取连接对象
        Connection conn = JDBCUtils.getConn();
        // 创建QueryRunner对象
        QueryRunner qr = new QueryRunner();
        String sql = "delete from  sort  where sid=?";
        int row = qr.update(conn, sql, sid);
        return row;
    }

四 QueryRunner 实现查询操作

query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)，用来完成表数据的查询操作

1、ResultSetHandler（是个接口，需要实现类）结果集处理类：

2、JavaBean:（实体类---以前的domain包）

JavaBean就是一个类，在开发中常用封装数据。具有如下特性：

①、需要实现接口：java.io.Serializable ，通常实现接口这步骤省略了，不会影响程序。

②、提供私有字段：private 类型字段名;

③、提供getter/setter方法：

④、提供无参构造

package com.oracle.dao;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

import javax.management.Query;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import com.oracle.domain.Sort;
import com.oracle.tools.JDBCUtils;
import com.oracle.tools.MyDBUtils;

public class SortDao {
//    新增
    public int addSort(Integer sid,String sname) throws SQLException{
/*//        获取连接对象
        Connection conn=JDBCUtils.getConn();*/
//        创建QueryRunner对象
        QueryRunner qr=new QueryRunner(MyDBUtils.getDataSource());
        String sql="insert into sort values(?,?)";
        int row=qr.update(sql,sid,sname);
        return row;
    }
//    修改
    public int update(Integer sid,String sname) throws SQLException{
//        获取连接对象
        Connection conn=JDBCUtils.getConn();
//        创建QueryRunner对象
        QueryRunner qr=new QueryRunner();
        String sql="update sort set sname=? where sid=?";
        int row=qr.update(conn,sql,sname,sid);
        return row;
    }
//    删除
    public int delete(Integer sid) throws SQLException{
//        获取连接对象
        Connection conn=JDBCUtils.getConn();
//        创建QueryRunner对象
        QueryRunner qr=new QueryRunner();
        String sql="delete from sort where sid=?";
        int row=qr.update(conn,sql,sid);
        return row;
    }
//    ArrayListHandler查询:结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中
    public List<Object[]> get1() throws SQLException{
//        获取连接对象
        Connection conn=JDBCUtils.getConn();
//        创建QueryRunner对象
        QueryRunner qr=new QueryRunner();
        String sql="select * from sort";
        List<Object[]> obj=qr.query(conn,sql,new ArrayListHandler());
        return obj;
    }
//    BeanHandler查询:结果集中第一条记录封装到一个指定的javaBean
    public Sort get2(Integer sid,String sname) throws SQLException{
//        获取连接对象
        Connection conn=JDBCUtils.getConn();
//        创建QueryRunner对象 
        QueryRunner qr=new QueryRunner();
        String sql="select * from sort where sid=? and sname=?";
//                                        BeanHandler<泛型>+类型字节码文件对象
        Sort sort=qr.query(conn,sql,new BeanHandler<Sort>(Sort.class),sid,sname);
        return sort;
    }
//    BeanListHandler查询:结果集中每一条记录封装到一个指定的javaBean，将这些javaBean在封装到List集合中
    public List<Sort> get3() throws SQLException{
//        获取连接对象
        Connection conn=JDBCUtils.getConn();
//        创建QueryRunner对象
        QueryRunner qr=new QueryRunner();
        String sql="select * from sort";
        List<Sort> arr=qr.query(conn, sql,new BeanListHandler<Sort>(Sort.class));
        return arr;
    }
//    ColumnListHandler查询 :指定的列的字段值，封装到一个List集合
    public List<String> get4() throws SQLException{
//        获取连接对象
        Connection conn=JDBCUtils.getConn();
//        创建QueryRunner对象
        QueryRunner qr=new QueryRunner();
        String sql="select * from sort";
//                                                        这里写指定那一列的泛型，指定名字
        List<String> list=qr.query(conn,sql,new ColumnListHandler<String>("sname"));
        return list;
    }
    
//    ScalarHandler查询 :单数据查询，例：count(*),默认Long类型
    public Integer get5() throws SQLException{
/*        获取连接对象
　      Connection conn=JDBCUtils.getConn();*/
//        创建QueryRunner对象　　这里用了连接池后，就不用在获取连接对象
        QueryRunner qr=new QueryRunner(MyDBUtils.getDataSource());
        String sql="select count(*) from sort";
        Long count=qr.query(sql,new ScalarHandler<Long>());
//        这里需要转换，Long转Integer
        return count.intValue();//包装类型转换 intValue
        }
    }

测试 ---------------------------------------- Demo

package com.oracle.test;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

import org.apache.commons.dbutils.QueryRunner;

import com.oracle.dao.SortDao;
import com.oracle.domain.Sort;
import com.oracle.tools.JDBCUtils;

public class Demo {
    public static void main(String[] args) throws SQLException {
        SortDao sortDao=new SortDao();
        /*新增测试
        int row=sortDao.addSort(20, "服饰");
        System.out.println(row);*/
        
        /*修改测试
        int row1=sortDao.update(20, "香水");
        System.out.println(row1);*/
        
        /*删除测试
        int row=sortDao.delete(20);
        System.out.println(row);*/
        
        /*ArrayListHandler测试
        List<Object[]> obj=sortDao.get();
        //遍历
        for (Object[] o:obj) {
            for (Object oo:o) {
                System.out.println(oo);
            }
        }*/
        /*BeanHandler查询
        Sort sort=sortDao.get2(9, "家电");
        System.out.println(sort);*/
        
        /*BeanListHandler查询
        List<Sort> arr=sortDao.get3();
        System.out.println(arr);*/
        
        /*ColumnListHandler查询
        List<String> arr=sortDao.get4();
        System.out.println(arr);*/
        
//        ScalarHandler查询
        int count=sortDao.get5();
        System.out.println(count);
    }    
}

五、连接池

1、概述：

　　用池管理Connection，可以重复使用Connection。有了池，我们就不用自己来创建Connection，通过池来获取Connection对象。当使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池。池就可以再利用这个Connection对象了。（不调用的话自动归还）

2、规范：

　　Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池！

常见连接池：DBCP、C3P0。

3、DBCP连接池：

①、导包：commons-dbcp-1.4.jar commons-pool-1.5.6.jar

②、编写工具类：

连接数据库表的工具类, 采用DBCP连接池的方式来完成，Java中提供了一个连接池的规则接口：

　　DataSource ：是java中提供的连接池，作为 DriverManager 工具的替代项。在DBCP包中提供了DataSource接口的实现类，我们要用的具体的连接池 BasicDataSource类：

先导包

有了DBUtils后，我们以后就无需在写获取连接对象了，在创建 QueryRunner 对象时，直接从连接池里获取随机池就可以了，这样就省了不少代码

package com.oracle.tools;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;

public class MyDBUtils {
    public static final String DRIVER = "com.mysql.jdbc.Driver";
    public static final String URL = "jdbc:mysql://localhost:3306/java0603?useUnicode=true&characterEncoding=UTF-8";
    public static final String USERNAME = "root";
    public static final String PASSWORD = "123456";
    /*
     * 创建连接池BasicDataSource
     */
    public static BasicDataSource dataSource = new BasicDataSource();
    //静态代码块(优先只执行一次）
    static {
        //对连接池对象 进行基本的配置
        dataSource.setDriverClassName(DRIVER); // 这是要连接的数据库的驱动
        dataSource.setUrl(URL); //指定要连接的数据库地址
        dataSource.setUsername(USERNAME); //指定要连接数据的用户名
        dataSource.setPassword(PASSWORD); //指定要连接数据的密码
    }
    /*
     * 返回连接池对象
     */
    public static DataSource getDataSource(){
        return dataSource;
    }
}

3、常见配置项：