Java EE 基本开发流程及数据库连接池 Druid

一、 公司开发基本流程
    a. 了解需求信息（比较模糊）
        需求，不是别人告诉你的，是你自己挖掘出来的。
        售前工程师(对行业知识了解)：编程学不好，但懂点代码，对人的综合能力要求比较高

    b. 产品经理：
        整理需求，了解，从网上找些竞品分析。[3,5 个同类产品]
        竞品分析：
            1. 客户人群（流量）
            2. 市场前景
            3. 功能（优劣势）

    c. 产品设计师：
            通过竞品分析，做个系统原型（线框图/草图）通过ps/axture/c4d把原型做出来
            页面优势，技术优势，我们做的系统功能优势，交互效果（感觉）（研究人的行为）

    d. 原型会给客户做展示（ppt axture）

    e. 前端程序员：照着原型去做静态的页面（HTML5/CSS3/JS）
        设计人员与前端对接
        静态 Demo 做出来

    f. 后台程序员：拿着静态 Demo 做成真正带功能的东西。
    g. 静态 Demo ：根据这个 Demo 看到这个系统要做哪些功能。
    h. 需求分析： 概要设计  项目的详细设计 OOA/OOD
        功能：划分模块
            例子： 产品模块 ： 产品分类  产品信息  
                    订单模块：
                      购物车：
                    个人中心：
                    商铺模块：
                    物流模块：
                    支付模块：
    I. 开发阶段：
            你要每个功能模块，做E-R图（实体关系模型图）
            工具：Rose（IBM开发 笨重）    PD（PowerDesigner  轻量级）
    J. 根据E-R图建立数据库(SQL关系型是数据库，NoSQL 不仅仅是关系数据库)
    K. 实体类    Dao类  Service类  Servlet类 ...
    L. 测试上线

注意：切记要有规范：(制定规范)

　　　例如：类名：XXXServlet
    
二、数据库连接池

1.连接池的出现

　　普通的jdbc：
    　　驱动：jdbc接口的实现类
    　　DriverManager（驱动管理器）：获取数据连接 Connection
    　　Statement ResultSet等：Connection
            　　connect
    　　jdbc<--------------->DB   

　　　　时间浪费在：  建立一次连接 销毁一次连接    效率不高，真正的开发中也不会这么做。

    连接池的出现：        
    　　jdbc<---------连接池------------>DB        缓存机制
   　　 Sun公司的人： 一套接口 DataSource（数据源），他就是数据库连接池的标准规范
       　　 DataSource：谁实现？
            　　c3p0 : Hibernate
            　　druid: 阿里

2. 如何编写数据库连接池：
    （1）引入 Jar 包  数据库的驱动，在pom.xml引入地址   JDBC的实现类
    （2）引入数据库连接池的实现类，在pom.xml引入地址   Druid

3. 实现：

　　Maven项目包：

 　　Project Directory
    　　entity: 实体类
    　　dao:    持久层
        　　prototype(原型)
        　　impl
    　　service:业务层代码
        　　prototype
        　　impl
    　　servlet:控制层
    　　util:工具类

　(1). pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.uek.project</groupId>
  <artifactId>airsys</artifactId>
  <version>0.1</version>
  <packaging>war</packaging>
  <name>airplane</name>
   <!-- 2. 项目属性配置 -->
  <properties>
  <!-- 项目编码使用UTF-8 -->
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <!-- 忽略掉web.xml文件 ，因为我们使用servlet3.0开发web项目 -->
      <failOnMissingWebXml>false</failOnMissingWebXml>
  </properties>
  <!-- 3. 配置项目所需要的第三方jar 包 -->
  <dependencies>
          <!-- servlet api -->
           <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
     <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
     </dependency>
     
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.0</version>
        <scope>provided</scope>
    </dependency>
    
    <!-- MySQL数据库连接池 -->
    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.48</version>
    </dependency>
    
    <!-- Druid -->
    <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.20</version>
    </dependency>
    
  </dependencies>
  
      <!-- 配置构建插件 -->
      <build>
          <plugins>
              <plugin>
              <!-- 编译插件 -->
                  <artifactId>maven-compiler-plugin</artifactId>
                  <version>3.5.1</version>
                  <configuration>
                      <source>1.8</source>
                      <target>1.8</target>
                  </configuration>
              </plugin>
              <!-- Tomcat 插件 -->
              <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8080</port>
                    <path>/airsys</path>
                    <!-- 实现热部署，不需要每次修改代码后都重新启动Tomcat -->
                    <contextReloadable>true</contextReloadable>
                </configuration>
            </plugin>
            
            
          </plugins>
      </build>
</project>

　　(2).　druid.properies

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/demo
username=root
password=root

#Druid连接池
initialSize=5
# 初始化连接池里建立的数量 ：5
maxActive=10
# 最大的连接数量：10
maxWait=3000
# 等待时间：3s

　　(3).　　DruidUtil.java

package util;


import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSourceFactory;


/**
 * 数据库连接池工具
 * @author 儿子
 *
 */
public class DruidUtil {
    
    private static DataSource ds;
    
    /**
     * 静态代码块  加载配置文件信息  只读取一次
     */
    static {
        //-- 1. 加载配置文件信息
        Properties ps = new Properties();     //-- Map<Object,object>
        //-- 2. 建立到配置文件流
        InputStream in = DruidUtil.class.
                getClassLoader().getResourceAsStream("druid.properties");
        //-- 3.读取配置文件的数据
        try {
            ps.load(in);
            ds = DruidDataSourceFactory.createDataSource(ps);
        } catch (Exception e) {
            System.out.println("读取配置文件异常");
        }
        
        //-- 4. 通过配置信息建立数据源对象DataSoure(其实就是连接池对象)
        try {
            DruidDataSourceFactory.createDataSource(ps);
        } catch (Exception e) {
            System.out.println("建立数据源对象DataSoure异常");            
        }
    }
    /**
     * 获取连接对象
     * @return Connection
     */
    public static Connection getConnection() {
        
        //-- 通过连接池获取连接对象
        Connection con = null;
        try {
            con = ds.getConnection();
        } catch (SQLException e) {
            System.out.println("JDBC 获取连接异常");
        }
        return con;
    }
    
    /**
     * 释放文件资源
     * @param stmt
     * @param con
     */
    public static void close (Statement stmt, Connection con) {
        if(stmt!=null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (con != null ) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 释放文件资源
     * @param rs
     * @param stmt
     * @param con
     */
    public static void close(ResultSet rs, Statement stmt, Connection con) {
        if (rs != null ) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stmt!=null) {
            try {
                stmt.close();
            } catch (SQLException e) {    
                e.printStackTrace();
            }
        }
        if (con != null ) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    
    public static void main(String[] args) {}
}

　　（4）　测试是否成功

　　　　a. 将druid.properties 复制到 test/resources/ 下

　　　　b. 新建编写类 TestDruid.java

　　　　　　

 　　　　c. TestDruid.java

import java.sql.Connection;
import java.sql.Statement;

import util.DruidUtil;

/**
 * 测试连接池工具类
 * @author 儿子
 *
 */
public class TestDruid {
    public static void main(String[] args) throws Exception {
        //-- 1. 获取连接对象
        Connection con = DruidUtil.getConnection();
        //-- 2. 定义sql语句
        String sql = "Create table student(id int,name varchar(20))";
        //-- 获取语句对象
        Statement stmt = con.createStatement();
        //-- 4. 执行Sql语句
        stmt.execute(sql);
        //-- 释放资源
        DruidUtil.close(stmt, con);
    }
}