JDBC , 使用java来控制mysql。JavaWeb开发的分层设计-三层架：DAO层设计，连接池使用，类加载使用，配置...
2024-05-20 04:43:02
大家可以关注一下我的博客 我的博客所有随笔都是我从基础开始学习java的所有知识点
1. Jdbc概述
问题：实际开发中，不可能用工具或者命令行操作数据库，数据库表中的数据最终要使用Java程序来操作,那么Java中如何操作数据库中的数据呢？
答 ： 在Java语言中，有一个专门连接数据库的规范（JDBC），专门负责连接数据库进行数据操作的规范
JDBC只是SUN编写的一堆接口（规范的体现），SUN公司自己并没有实现
问题 ： 为什么SUN只定义一个JDBC规范，而不实现呢？
答 ： 因为市面上的数据库很多，每个数据库内部接口不会向外暴露，而且即便是暴露让SUN去实现，市面上很多数据库全部要SUN来实现不现实
实际中哪个数据库需要支持JAVA语言，就需要自己实现Java的JDBC规范，因为实现了JDBC很多接口，那么就会有很多实现类，而很多实现类在java中会使用一个专门的包封装起来，叫做jar包（在JDBC中叫做驱动包），各大数据库产商实现JDBC规范以后都会把他们jar包放在官网上以供开发者下载使用
JDBC：(Java DataBase Connectivity):
是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。
JDBC规范对应的api包
案例使用JDBC操作MySQL数据库：
1. 创建普通java项目
2. 在项目下面新建一个lib目录（new键--》folder）
3. 将MySQL驱动包拷贝到项目中并添加依赖（build path--》add to build path）
4. 开始写代码
DDL创建表：
package jdbc;
//连接使用oracle数据库import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;import org.junit.Test;public class Test01 {/*** Java中单元测试方法的 创建* * 在空白处 写 test，使用快捷键 alt+/ 提示，选择 junit4* 会自动补全 junit4单元测试的方法* 在方法上面有一个注解，默认报错的* 因为：单元测试是一个框架，默认eclipse以及集成了，用户把鼠标放置在 注解上面，按提示导入junit4 依赖即可* 单元测试方法和main方法区别* junit单元测试方法在一个类中可以有多个方法，每个一个方法可以独立运行* main 主方法一个类中只能有一个方法，不太方便多个功能的测试* * 单元测试方法的运行，光标放置在单元测试方法上面，点击数据右键 【run as ->junit test】* 绿条：表示成功* 红条：表示程序可能异常*/@Test
public void testName1() throws Exception {//创建表操作:要执行的sql代码String sql="create table t_student(sid number(4) constraint pk_sid primary key,name varchar2(20))";//1，加载注册驱动Class.forName("oracle.jdbc.OracleDriver");/*加载注册驱动.(mysql的)就是把驱动中的Driver字节码加载到JVM中.Class.forName("com.mysql.jdbc.Driver");为什么这句话就可以加载注册驱动?第一步:把com.mysql.jdbc.Driver.class这份字节码加载到JVM中.第二步:当一份字节码被加载进JVM,马上就会执行该字节码中的静态代码块.第三步:该静态代码中,就在完成,先创建驱动对象,再注册.* */ //2，获取数据库连接（"jdbc:oracle:thin:@127.0.0.1:1521:数据库名","账号","密码"）Connection conn= DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:orcl","scott","tiger");/*jdbc:mysql://localhost:3306/dbNamejdbc:mysql:// ：连接MySQL数据库的协议，不同数据库协议不一样localhost:3306 ：数据库软件的主机和端口dbName ： 具体要连接数据库验证已经获取连接:可以在MySQL控制台,使用命令:show processlist; 查看MySQL运行进程.* *///3，创建语句对象（用于执行SQL语句的对象）Statement c = conn.createStatement();//4， 执行SQL语句
c.executeUpdate(sql);//5，释放资源(先开后关)
c.close();conn.close();}
}package jdbc;
//连接使用mysql数据库import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;import org.junit.Test;public class Test02 {
@Test
public void testName1() throws Exception {//创建一个学生表//创建表的mysql操作：要执行的sql代码 String sql="create table t_student(id int primary key auto_increment,name varchar(50),age int)";//1.加载注册驱动Class.forName("com.mysql.jdbc.Driver");//2.获取数据库连接对象Connection conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/lin01", "root", "root");//3.创建语句对象（用于执行SQL语句）Statement st=conn.createStatement();//4.执行SQL语句
st.executeUpdate(sql);//5.释放资源(先开后关)
st.close();conn.close();}
}DML：表的增删改：
package jdbc;
//连接使用mysql数据库import static org.junit.Assert.*;import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;import org.junit.Test;public class Test02 {
@Test
public void testName1() throws Exception {//DML 增://创建表的mysql操作：要执行的sql代码 String sql=("insert into t_student(name,age) values ('张三',20)");//1.加载注册驱动Class.forName("com.mysql.jdbc.Driver");//2.获取数据库连接对象Connection conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/lin01", "root", "root"); //3.创建语句对象（用于执行SQL语句）Statement st=conn.createStatement();//4.执行SQL语句
st.executeUpdate(sql);//5.释放资源(先开后关)
st.close();conn.close();}public void testName2() throws Exception{//DML 删:
String sql=("delete from t_student where id=2");Class.forName("com.mysql.jdbc.Driver");Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lin01", "root", "root");Statement st=conn.createStatement();st.executeUpdate(sql);st.close();conn.close();}
@Test
public void testName3() throws Exception {//DML 改:String st="update t_student set name='李四',age=15 where id=1";Class.forName("com.mysql.jdbc.Driver");Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lin01", "root", "root");Statement cr= conn.createStatement();cr.executeUpdate(st);cr.close();conn.close();}}DQL表的查询：
package jdbc;
//学生类
public class Student {private int id ;private String name;private Integer age;public int getId() {return id;
}public void setId(int id) {this.id = id;
}public String getName() {return name;
}public void setName(String name) {this.name = name;
}public Integer getAge() {return age;
}public void setAge(Integer age) {this.age = age;
}public Student(int id, String name, Integer age) {super();this.id = id;this.name = name;this.age = age;
}public Student() {super();
}@Override
public String toString() {return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
}}package jdbc;
//连接使用mysql数据库import static org.junit.Assert.*;import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;import org.junit.Test;public class Test02 {
@Test
public void testName1() throws Exception {//多行查询String str="select * from t_student";Class.forName("com.mysql.jdbc.Driver");Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lin01", "root", "root");Statement cr = conn.createStatement();ResultSet ex = cr.executeQuery(str);//创建一个学生类//申明一个list集合，封装一个个学生对象List<Student> stu = new ArrayList<Student>();while(ex.next()){//1.通过列的位置获取对应的数据 从1开始(如果不知道类型就用Object)Object id = ex.getObject(1);Object name = ex.getObject(2);Object age = ex.getObject(3);System.out.println(id+"\t"+name+"\t"+age);cr.close();conn.close();//2.通过列的名称获取对应的数据((知道类型就用相应的类型)int id1 = ex.getInt("id");String name1 = ex.getString("name");int age1 = ex.getInt("age");System.out.println(id1+"\t"+name1+"\t"+age1);cr.close();conn.close();//3.将每一行数据封装成一个个Student对象快速生成变量，光标放在 代码末尾， ctrl+1 提示int id2 = ex.getInt("id");String name2 = ex.getString("name");int age2 = ex.getInt("age");Student student = new Student(id2,name2,age2);stu.add(student);}for (Student student : stu){System.out.println(student);}ex.close();cr.close();conn.close();}}package jdbc;
//连接使用mysql数据库import static org.junit.Assert.*;import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;import org.junit.Test;public class Test02 {
@Test
public void testName1() throws Exception {//单行查询String str="select * from t_student where id=7";Class.forName("com.mysql.jdbc.Driver");Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lin01", "root", "root");Statement cr = conn.createStatement();ResultSet ex = cr.executeQuery(str);List<Student> stu=new ArrayList<Student>();if(ex.next()){int id = ex.getInt("id");String name = ex.getString("name");int age = ex.getInt("age");Student stud=new Student(id,name,age);stu.add(stud);}System.out.println(stu);
}}预编译语句对象PreparedStatment
问题 ： 我们有了Statment对象可以执行SQL，为什么还要使用PreparedStatment？
优势
- SQL语句结构清晰，参数的设置和SQL语句分离
- 性能更高
- 防止SQL注入
Statement: 表示静态SQL语句对象.
PreparedStatement:Statement的子接口,表示预编译SQL语句对象. 通过占位符(?)来拼SQL.
package jdbc;
//连接使用mysql数据库import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;import org.junit.Test;public class Test02 {
@Test
public void testName1() throws Exception {//使用预编译语句对象执行DML操作//模板sql语句(增加数据)String sql="insert into t_student(name,age) values(?,?) ";/**删除：String sql = "delete from t_student where id = ?";* 修改：String sql = "update t_student set name = ?,age=? where id = ?";*/// 1.加载注册驱动Class.forName("com.mysql.jdbc.Driver");// 2.获取数据库连接对象Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lin01", "root", "root");// 3.创建预编译语句对象PreparedStatement pr = conn.prepareStatement(sql);//3.1设置预编译语句对象占位符对应的参数值pr.setString(1, "maxysh");pr.setInt(2, 99);// 4.执行SQL语句 (注意：方法不能带sql参数)
pr.executeUpdate();// 5.释放资源
pr.close();conn.close();}
} package jdbc;
//连接使用mysql数据库import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;import org.junit.Test;public class Test02 {
@Test
public void testName1() throws Exception {//使用预编译语句对象执行DML操作//模板sql语句(查询数据)String sql="select * from t_student ";// 1.加载注册驱动Class.forName("com.mysql.jdbc.Driver");// 2.获取数据库连接对象Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/lin01", "root", "root");// 3.创建预编译语句对象PreparedStatement pr = conn.prepareStatement(sql);// 4.执行SQL语句 (注意：方法不能带sql参数)ResultSet ex = pr.executeQuery();//申明一个list集合，封装一个个学生对象List<Student> students = new ArrayList<Student>();while(ex.next()){int id = ex.getInt("id");String name = ex.getString("name");int age = ex.getInt("age");Student stu=new Student(id,name,age);students.add(stu);}System.out.println(students);// 5.释放资源
ex.close();pr.close();conn.close();}} JavaWeb开发的分层设计-三层架构
DAO层设计
实际开发中，JavaWeb开发代码一般分为三层,分层结构是JavaWeb开发中的一种设计思想，这样会让我们开发层次分明，每一层只要完成对应的功能即可，使得项目便于开发和维护
1 . Web层/表现层 ： 主要接受前台浏览器用户的参数，给浏览器响应数据等等
2.Service层/业务成/服务层：主要处理业务功能，日志，权限，事物，等等
3.DAO层/持久层 ：专门负责和数据库交互，数据处理相关代码
DAO ： Data Access Object 数据访问对象
实际开发中 ： 用户请求到-Web层--->Service层-->DAO层
使用DAO以后代码的以及包的设计结构
开发中如果使用的分层，编写的包和类名接口名等等都是有固定规则，不能随便瞎写
DAO层接口包命名
公司域名倒写+项目名称/模块名称+dao 如 ： cn.sxt.crm.dao
DAO层实现类包命名
公司域名倒写+项目名称/模块名称+dao+impl 如 ： cn.sxt.crm.dao.impl
DAO层操作对应表的接口命名
对应表的名称 + Dao/DAO 如 ： StudentDao/DAO , TeacherDao/DAO
DAO层操作对应表的实现类命名
对应表的名称 + Dao/DAOImpl 如 ： StudentDaoImpl/DAOImpl , TeacherDaoImpl/DAOImpl
数据表对应的Java类domain/pojo包命名
POJO（Plain Ordinary Java Object）简单的Java对象
domian ： 域对象
公司域名倒写+项目名称/模块名称+domain/pojo 如 ： cn.sxt.crm.domain
对应的测试包命名
公司域名倒写+项目名称/模块名称+test 如 ： cn.sxt.crm.test
项目的工具类包命名
公司域名倒写+项目名称/模块名称+util/utils 如 ： cn.sxt.crm.util/utils
package cn.sxt.crm.test;import java.io.InputStream;
import java.util.Properties;import org.junit.Test;
/*new --->file* ClassLoader 类加载器* ClassLoader ：可以从项目的类路径下面读取对应的配置文件返回一个输入流* ClassLoader 在程序运行的时候JVM已经为每一个项目都创建了一个，我们开发者只需要获取即可* 获取类加载器方式* 1、使用当前线程* ClassLoader classLoader = Thread.currentThread().getContextClassLoader();* 2、通过某一类的字节码实例也可以获取* ClassLoader classLoader = PropertiesTest.class.getClassLoader();*/
//ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
//使用类加载器获取项目 类路径下面的文件
//InputStream inputStream = classLoader.getResourceAsStream("db.properties");/*
* Properties 是Map集合下面的一个 专门用于读取配置文件的对象
* 可以读取当前类路径下面的 xxx.properites类型的配置文件
*
* xxx.properites的内容必须是key=value 键值对的数据
*/public class PropertiesTest {@Testpublic void test1() throws Exception {//1.使用当前线程可以获取类加载器ClassLoader classLoader = Thread.currentThread().getContextClassLoader();//2.使用类加载器读取db.properties配置文件InputStream in = classLoader.getResourceAsStream("dp.properties");//3.创建Properties对象（专门读取xxx.properties配置文件中的内容，本质就是Map集合，数据结构key--->value）Properties p = new Properties();//4.加载配置文件
p.load(in);System.out.println(p);//5.获取单个指定key的值String str1=p.getProperty("str1");String str2=p.getProperty("str2");String str3=p.getProperty("str3");String str4=p.getProperty("str4");System.out.println(str1);}}package cn.sxt.crm.test;import static org.junit.Assert.*;import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;import javax.sql.DataSource;import org.junit.Test;import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;//Druid连接池的使用
public class DateSourceTest {
@Test//直接手动创建连接池对象
public void testName1() throws Exception {//1.创建druid连接池对象DruidDataSource ds = new DruidDataSource();ds.setDriverClassName("com.mysql.jdbc.Driver");ds.setUrl("jdbc:mysql://localhost:3306/lin01");ds.setUsername("root");ds.setPassword("root");//设置最大连接数ds.setMaxActive(10);Connection conn = ds.getConnection();System.out.println(conn);
}
//使用Druid工厂对象读取配置文件来创建连接池对象
@Test
public void testName() throws Exception {//获取类加载器ClassLoader classLoader=Thread.currentThread().getContextClassLoader();InputStream in=classLoader.getResourceAsStream("dp.properties");Properties properties=new Properties();properties.load(in);//使用工厂创建连接池对象DataSource ds=DruidDataSourceFactory.createDataSource(properties );Connection conn = ds.getConnection();System.out.println(conn);}
}str1=com.mysql.jdbc.Driver str2=jdbc:mysql://localhost:3306/lin01 str3=root str4=root maxActive=10
-----------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------
package cn.sxt.crm.dao;import java.util.List;import cn.sxt.crm.pojo.Student;public interface StudentDao {/*** 插入方法* @param stu 封装有学生信息的Student对象(数据库自增id，开发者不需要传id)* @return 受影响的行数*/
int insert(Student stu);//增方法/*** 根据主键删除数据* @param id 主键id的值* @return 受影响的行数*/
int delete(Integer id);/*** 修改操作* @param stu 带有id值的Student对象（修改根据主键id值修改）* @return 受影响的行数*/int update(Student stu);/*** 单行查询* @param id 主键id* @return 单行数据封装的对象*/
Student selectByPrimaryKey(Integer id);/*** 多行查询* @return 封装有一个个Student对象的集合*/List<Student> selectList();}package cn.sxt.crm.dao.impl;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import cn.sxt.crm.dao.StudentDao;
import cn.sxt.crm.pojo.Student;
import cn.sxt.crm.util.utils;public class StudentDaoImpl implements StudentDao {@Overridepublic int insert(Student stu) {String sql="insert into t_student(name,age)values(?,?)";Connection conn=null;PreparedStatement pr=null;try {conn =utils.getConnection();pr = conn.prepareStatement(sql);pr.setString(1,stu.getName());pr.setInt(2, stu.getAge());int row=pr.executeUpdate();return row;} catch (Exception e) {e.printStackTrace();}finally{utils.close(conn, pr, null);}return 0;}@Overridepublic int delete(Integer id) {String sql="delete from t_student where id=?";Connection conn=null;PreparedStatement pr=null;try {conn = utils.getConnection();pr = conn.prepareStatement(sql);pr.setInt(1,id);int row=pr.executeUpdate();return row;} catch (Exception e) {e.printStackTrace();}finally{utils.close(conn, pr, null);}return 0;}@Overridepublic int update(Student stu) {String sql="update t_student set name=?,age=? where id=?";Connection conn=null;PreparedStatement pr=null;try {conn =utils.getConnection();pr = conn.prepareStatement(sql);pr.setString(1,stu.getName());pr.setInt(2, stu.getAge());pr.setInt(3, stu.getId());int row=pr.executeUpdate();return row;} catch (Exception e) {e.printStackTrace();}finally{utils.close(conn, pr, null);}return 0;}@Overridepublic Student selectByPrimaryKey(Integer id) {String sql="select * from t_student where id=?";Connection conn=null;PreparedStatement pr=null;ResultSet ex=null;try {conn = utils.getConnection();pr = conn.prepareStatement(sql);pr.setInt(1,id);ex = pr.executeQuery();while(ex.next()){String name=ex.getString("name");int age=ex.getInt("age");// 封装Student对象Student stu = new Student(id, name, age);//返回Student对象return stu;}} catch (Exception e) {e.printStackTrace();}finally{utils.close(conn, pr, ex);}return null;}@Overridepublic List<Student> selectList() {List<Student> student= new ArrayList<Student>();String sql="select * from t_student";Connection conn=null;PreparedStatement pr=null;ResultSet ex=null;try {conn =utils.getConnection();pr = conn.prepareStatement(sql);ex = pr.executeQuery();while(ex.next()){int id=ex.getInt("id");String name=ex.getString("name");int age=ex.getInt("age");// 封装Student对象Student stu = new Student(id, name, age);// 学生对象添加到集合中
student.add(stu);}} catch (Exception e) {e.printStackTrace();}finally{utils.close(conn, pr, ex);}return student;}}package cn.sxt.crm.pojo;public class Student {
private Integer id;
private String name;
private Integer age;
public Integer getId() {return id;
}
public void setId(Integer id) {this.id = id;
}
public String getName() {return name;
}
public void setName(String name) {this.name = name;
}
public Integer getAge() {return age;
}
public void setAge(Integer age) {this.age = age;
}
public Student(Integer id, String name, Integer age) {super();this.id = id;this.name = name;this.age = age;
}
public Student() {super();
}
@Override
public String toString() {return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
}}package cn.sxt.crm.test;import java.util.List;import org.junit.Test;import cn.sxt.crm.dao.StudentDao;
import cn.sxt.crm.dao.impl.StudentDaoImpl;
import cn.sxt.crm.pojo.Student;public class StudentDaoTest {private StudentDao dao=new StudentDaoImpl();@Testpublic void testInsert() {Student stu=new Student(null, "叶孤城", 30);int row=dao.insert(stu);System.out.println(row);}@Testpublic void testDelete() {int row=dao.delete(10);System.out.println(row);}@Testpublic void testUpdate() {Student stu=new Student(9, "叶孤城", 30);int row=dao.update(stu);System.out.println(row);}@Testpublic void testSelectByPrimaryKey() {Student stu = dao.selectByPrimaryKey(3);System.out.println(stu);}@Testpublic void testSelectList() {List<Student> students = dao.selectList();System.out.println(students);}}package cn.sxt.crm.util;import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;import javax.sql.DataSource;import com.alibaba.druid.pool.DruidDataSourceFactory;public class utils {// 创建读取配置文件的配置对象private static Properties p=new Properties(); //连接池对象private static DataSource da;static {try {ClassLoader classLoader=Thread.currentThread().getContextClassLoader();InputStream inputStream=classLoader.getResourceAsStream("dp.properties");p.load(inputStream);//创建连接池对象da= DruidDataSourceFactory.createDataSource(p);} catch (Exception e) {e.printStackTrace();}}public static Connection getConnection(){try {Connection conn = da.getConnection();return conn;} catch (Exception e) {throw new RuntimeException("连接失败");}}public static void close(Connection conn,PreparedStatement pr,ResultSet ex){try {if(ex!=null){ex.close();}} catch (SQLException e1) {e1.printStackTrace();}finally{try {if(pr!=null){pr.close();}} catch (SQLException e) {e.printStackTrace();}finally{try {if(conn!=null){conn.close();}} catch (SQLException e) {e.printStackTrace();} }}}}driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/lin01
username=root
password=root
maxActive=1
配置必须按规定命名，
转载于:https://www.cnblogs.com/406070989senlin/p/10887305.html
JDBC , 使用java来控制mysql。JavaWeb开发的分层设计-三层架：DAO层设计，连接池使用，类加载使用，配置...相关推荐
- Spring Boot开发基于三层架构设计：Dao层、Service层、Controller层
三层架构设计:基于Spring Boot开发要使用三层架构: 数据访问层(Dao).业务逻辑层(Service).控制层(Control-ler) (1)数据访问层(Dao):Dao层是最底层的设计, ...
- mysql 连接池 数量_mysql合理配置连接池数量
我们经常会遇见"MySQL: ERROR 1040: Too many connections"的情况,一种是访问量确实很高,MySQL服务器抗不住,这个时候就要考虑增加从服务器分 ...
- java语言的Dao层设计（一）—— Dao层基本结构设计
Dao层--数据访问层 Dao层是具体到每个操作,每个表的增删查改.那怎么写这个数据访问层呢?首先是数据库的设计以及所计划实现的功能,之后是IBean.IDao这两个基础接口以及这两个接口的实现,再之 ...
- stripes java,利用Stripes实现JavaWeb开发
Stripes是一个以让程序员的web开发简单而高效为准则来设计的基于动作的开源Java web框架.本文将介绍Stripes与其它如Struts之类基于动作的框架的区别和其提供的一些存在于Ruby ...
- 01-JDBC概念--JDBC（Java Database Connectivity：Java数据库连接）：使用jdbc实现Java与数据库MySQL连接
JDBC自学教程–终篇总结: 地址:http://blog.csdn.net/baidu_37107022/article/details/72600018 1.JDBC(Java Database ...
- Java job interview:项目开发小组成员网站数据访问层设计
在前面简单描述了下服务层,SOA面向服务架构,架构设计-业务逻辑层,以及一些面面向设计原则理解和软件架构设计箴言.这篇博客我们将继续进入我们的下一层:数据访问层.无论你用的是什么开发模式或者是业务模式 ...
- JavaWeb中连接数据库的一般方式与通过JNDI连接池的方式
一 概念介绍: 1.连接池 Connection的取得和开放是代价比较高的处理,解决这个问题的方法是连接池. 连接池就是事先取得一定数量的Connection,程序执行处理的时候不是新建C ...
- Tomcat7和mysql连接池dbcp方式的配置方法和测试
一.设计测试用的数据库 1.新建数据库 create database testmysql; 2.新建一个用户信息数据表 create table test( username varchar(20) ...
- jetty java web_i-jetty 下的JavaWeb开发（一）
最近需要将android端作为服务器进行开发,让android作为服务器,现阶段技术并不是很成熟,主要的服务器有i-jetty,是基于PC端的jetty的移植.i-jetty同tomcat类似,也是S ...
最新文章
- java使用Jsch实现远程操作linux服务器进行文件上传、下载，删除和显示目录信息...
- 特征工程之离散变量处理
- (转)解决Android SDK Manager无法更新或下载太慢问题
- android display list,从android.view.GLES20DisplayList释放位图
- python123动物重量排序_python基本常识
- VS2015 将*.xaml.cs文件包裹在*.xaml文件下
- 性能测试工具curl-loader(linux)
- linux内外部命令,Shell、内外部命令――Linux基本命令（2）
- C# winform post请求数据
- 上海交通大学软件学院2005学年度第一学期工程硕士课程安排表
- QNX多线程同步之Barrier(屏障)
- 【电商系统】—项目缺陷管理（二）
- webpack--安装，使用
- Effective C# Item47：选择安全代码
- node.js的初步见解
- C++标准库分析总结(一)
- linux .cache目录,关于linux系统下的cache Memory
- Android调用自带TTS文本转语音引擎实现离线语音合成
- 【第1164期】从前端技术到体验科技
- deep learning for the earth sciences 读书笔记