集合、多线程、网络编程、JDBC、连接池、反射、综合应用

1、使用TCP连接服务器和客户端。　　

2、结合反射的知识、创建JDBC和连接池。

3、客户端输入信息并保存到一个对象中，发送到服务器。

4、服务器接收对象，通过JDBC存储进数据库中。

5、把服务器放到线程中，保持启动状态。

6、客户端读取数据库的数据信息，放到集合中。

7、遍历集合，输出数据库的数据。

服务器和客户端的项目结构：

服务器

客户端

实体类：

package com.luo.project.pojo;

import java.io.Serializable;

public class User implements Serializable{
	/**
	 *
	 */
	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;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	public User(Integer id, String name, Integer age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public User() {
		super();
		// TODO Auto-generated constructor stub
	}

}

　　

Dao层：

package com.luo.project.dao;

import java.util.List;

import com.luo.project.pojo.User;

public interface UserDao {
//	插入用户
	public int insertUser(User user);

//	查询所有用户
	public List<User> queryAllUser();

}

Dao实现层：

package com.luo.project.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.alibaba.druid.stat.JdbcConnectionStat;
import com.luo.project.dao.UserDao;
import com.luo.project.pojo.User;
import com.luo.project.util.JDBCUtil;

public class UserDaoImpl implements UserDao {

	@Override
	public int insertUser(User user) {

		return JDBCUtil.insertUser(user);
	}

	@Override
	public List<User> queryAllUser() {

		return JDBCUtil.queryAllUser(User.class);
	}

}

JDBC工具类：

package com.luo.project.util;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.luo.project.pojo.User;

public class JDBCUtil {
	// 创建读取文件的properties类
	private static Properties properties = new Properties();

	private static DataSource dataSource=null;

	static {
		try {
			System.out.println("正在创建类加载器...");
			// 获取类加载器
			ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
			// 通过加载器获取项目下的配置文件的字节流
			InputStream inputStream = contextClassLoader.getResourceAsStream("db.properties");
			System.out.println("正在加载配置文件...");
			// 加载配置文件
			properties.load(inputStream);

			System.out.println("配置文件加载完毕...");

			dataSource=DruidDataSourceFactory.createDataSource(properties);

			Class.forName(properties.getProperty("driverClassName"));
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static Connection getConnection() {

		try {
			return  dataSource.getConnection();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			throw new RuntimeException("连接失败！", e);
		}
	}

	public static void close(Connection connection, PreparedStatement ps, ResultSet rs) {
		if (connection != null) {
			try {
				connection.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				if (ps != null) {
					try {
						ps.close();
					} catch (SQLException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} finally {
						if (rs != null) {
							try {
								rs.close();
							} catch (SQLException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						}
					}
				}
			}
		}
	}

	public static int insertUser(Object obj) {
//		String sql="insert into User(name,age) values(?,?)";
		StringBuilder sb=new StringBuilder();
		sb.append("insert into ");
		sb.append(obj.getClass().getSimpleName());
		sb.append("(");
		Field[] fields = obj.getClass().getDeclaredFields();
		for (Field field : fields) {
			String fieldName = field.getName();
			sb.append(fieldName+",");
		}
		sb.deleteCharAt(sb.length()-1);
		sb.append(")");
		sb.append("values (");
		for (Field field : fields) {
			sb.append("?,");
		}
		sb.deleteCharAt(sb.length()-1);
		sb.append(")");

		Connection connection=null;
		PreparedStatement ps=null;
		try {
			connection=JDBCUtil.getConnection();
			connection.setAutoCommit(false);
			ps= connection.prepareStatement(sb.toString());

			for(int i=0;i<fields.length;i++){
//				字段数组
				Field field = fields[i];
				field.setAccessible(true);
				Object fieldValue = field.get(obj);
				ps.setObject(i+1, fieldValue);

			}

			int row = ps.executeUpdate();
			connection.commit();
			return row;						

		} catch (SQLException e) {
			try {
				connection.rollback();
			} catch (SQLException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			JDBCUtil.close(connection, ps, null);
		}

		return 0;
	}

	public static <T> List<T> queryAllUser(Class<T> clz) {
//		String sql="select * from user";
		String sql="select * from "+ clz.getSimpleName();
		Connection connection=null;
		PreparedStatement ps=null;
		ResultSet rs=null;
		List<T> list=new ArrayList<T>();

		try {

			connection=JDBCUtil.getConnection();
			connection.setAutoCommit(false);
			ps = connection.prepareStatement(sql);
			rs = ps.executeQuery();
			while(rs.next()){
				T object = clz.newInstance();

				Field[] Fields =  clz.getDeclaredFields();
				for (Field field : Fields) {
					String fieldName = field.getName();

					Object value = rs.getObject(fieldName);
					field.setAccessible(true);
					field.set(object, value);

				}

				list.add(object);

			}
			connection.commit();
			return list;

		} catch (Exception e) {
			e.printStackTrace();
			try {
				connection.rollback();
			} catch (SQLException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}finally{
			JDBCUtil.close(connection, ps, rs);
		}
		return null;
	}

}

服务器的主类和线程类：　

主类：

package com.luo.project.test;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

import com.luo.project.dao.impl.UserDao;
import com.luo.project.dao.impl.UserDaoImpl;
import com.luo.project.pojo.User;
import com.luo.project.thread.LoginThread;

//服务器
public class Service {

	public static void main(String[] args) throws IOException  {
		System.out.println("服务器启动...");
		ServerSocket serverSocket=serverSocket = new ServerSocket(9000);

//	每次客户端连接，都会实例一个socket对象
		while(true){
			Socket socket=serverSocket.accept();
			LoginThread loginThread = new LoginThread(socket);
			loginThread.start();

		}

	}

}

　　

　　线程：

package com.luo.project.thread;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

import com.luo.project.dao.impl.UserDao;
import com.luo.project.dao.impl.UserDaoImpl;
import com.luo.project.pojo.User;

public class LoginThread extends Thread {
	private Socket socket;
	public LoginThread(Socket socket) {
		super();
		this.socket=socket;
	}

	@Override
	public void run() {
		InputStream inputStream=null;
		ObjectInputStream objectInputStream=null;
		try {

			System.out.println("客户端已连接!");
//			接受客户端的数据
			inputStream = socket.getInputStream();
			objectInputStream=new ObjectInputStream(inputStream);
			User user = (User) objectInputStream.readObject();
			System.out.println(user);

//			将数据存入数据库中
			UserDao userDao=new UserDaoImpl();
			int row = userDao.insertUser(user);
			System.out.println("数据被影响的行数:"+row);

		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

　

客户端的主类：

package com.luo.project.test;

import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

import com.luo.project.dao.UserDao;
import com.luo.project.dao.impl.UserDaoImpl;
import com.luo.project.pojo.User;

//客户端
public class Client {

	public static void main(String[] args) {
		System.out.println("客户端启动...");
		Socket socket=null;
		OutputStream outputStream=null;
		Scanner scanner=new Scanner(System.in);
		ObjectOutputStream objectOutputStream=null;
		List<User> list=new ArrayList<>();
		try {
			socket=new Socket("127.0.0.1",9000);
			outputStream= socket.getOutputStream();
			objectOutputStream=new  ObjectOutputStream(outputStream);

			//向服务器发送数据
			System.out.print("请输入用户名称：");
			String name = scanner.nextLine();
			System.out.print("请输入用户年龄：");
			int age = scanner.nextInt();

			User user=new User(null, name, age);
			objectOutputStream.writeObject(user);
			objectOutputStream.flush();

			//遍历数据库
			UserDao userDao=new UserDaoImpl();
			List<User> users = userDao.queryAllUser();
			System.out.println("遍历数据库：");
			for (User u : users) {
				System.out.println(u);
			}

		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				objectOutputStream.close();
				outputStream.close();
				socket.close();

			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}

	}

}

　　

db.properties配置文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/first_project
username=root
password=123456
maxActive=10

　　

　

测试类：

package com.luo.project.test;

import java.util.List;

import org.junit.Test;

import com.luo.project.dao.impl.UserDao;
import com.luo.project.dao.impl.UserDaoImpl;
import com.luo.project.pojo.User;

public class UserTest {
	private UserDao userDao=new UserDaoImpl();

	@Test
	public void insertTest(){
		User user=new User(null, "乔布斯", 45);
		int insertUser = userDao.insertUser(user);
		System.out.println(insertUser);
	}

	@Test
	public void queryAllUser(){
		List<User> queryAllUser = userDao.queryAllUser();
		for (User user : queryAllUser) {
			System.out.println(user);
		}
	}

}

　

数据库表：

　

原文地址：https://www.cnblogs.com/luojack/p/10947051.html

时间： 2024-10-09 05:08:29

集合、多线程、网络编程、JDBC、连接池、反射、综合应用的相关文章

JDBC连接池C3P0

连接池 1)传统方式找DriverManager要连接,数目是有限的. 2)传统方式的close(),并没有将Connection重用,只是切断应用程序和数据库的桥梁,即无发送到SQL命令到数据库端执行 3)项目中,对于Connection不说,不会直接使用DriverManager取得,而使用连接池方式. 4)DBCP和C3P0,都是Java开源的,都必须直接或间接实现javax.sql.DataSource接口 5)DBCP连接池需要dbcp.properties文件,同时需加入3个对应的j

数据层优化-jdbc连接池简述、druid简介

终于回到既定轨道上了,这一篇讲讲数据库连接池的相关知识,线程池以后有机会再结合项目单独写篇文章(自己给自己挖坑,不知道什么时候能填上),从这一篇文章开始到本阶段结束的文章都会围绕数据库和dao层的优化去写,本篇是一个开始.本文会介绍连接池技术并对比目前比较流行的java连接池技术,之后,会把druid整合到项目中来,将技术方案落地,实际整合到项目中,让技术能为我所用. 使用连接池的原因 jdbc的demo //第一步,注册驱动程序 //com.MySQL.jdbc.Driver Class.fo

号称性能最好的JDBC连接池:HikariCP

HikariCP号称是现在性能最好的JDBC连接池组件,具体的性能到底如何,我也没有仔细的测试过,不过从它现在的发展来看,其可能确实如它宣传的那样其性能高过目前所有的连接池组件.之前对连接池的记忆一直都是C3P0.DBCP.BoneCP,这三者中BoneCP的性能是最好的,C3P0的性能在现在来说确实是非常差的了,好像C3P0很久都没有更新了,所以我们应该杜绝在项目中使用C3P0,至于是否要使用HikariCP,我觉得可以尝试.HikariCP毕竟是才出来不久,其性能到底如何,也需要实践的检验,

JDBC连接池的简单实现

先说明一下,我本身是做android开发的,java web是我的弱项,只是近来京东云免费,于是去折腾了几下,有了些许经验,特作分享.如果文章中内容有误,还请各高手指正. 我在web端,需要连接数据库进行查询插入等操作,但是每次进行操作都先获取连接用完后就断开的话,未免效率太低.以前知道tomcat中可以配置,但是京东云引擎的tomcat并不能由自己配置.因为我折腾的东西较小,所以也不考虑使用框架,于是就想自己写一个. 我写的连接池很简单,在初始化时创建5个连接,并放在一个列表当中.如果要获取连

使用了Tomcat JDBC连接池不能重连的问题

在项目中用到了tomcat 的jdbc连接池,发现一个问题是,当数据库重启时,服务没有重新的去连接数据库,需要将部署的项目重新启动才能连接到数据库.经过测试对配置做一下修改: 在配置dataSource的地方加入两个配置属性: <property name="testOnBorrow" value="true"/> <!--在连接返回给调用者前用于校验连接是否有效的SQL语句,如果指定了SQL语句,则必须为一个SELECT语句,且至少有一行结果--

JDBC连接池概述

Reference Source:https://www.progress.com/tutorials/jdbc/jdbc-jdbc-connection-pooling 介绍 本文档提供的信息旨在帮助开发人员为必须处理连接池的应用程序提供连接池策略. 首先, 本文档提供 jdbc 3.0 规范指定的 jdbc 连接池概述. 接下来, 它提供了一些示例, 说明如何使用 DataDirect 连接池管理器 (它随 DataDirect Connect?用于jdbc 和 DataDirect Seq

Spring boot (11) tomcat jdbc连接池

默认连接池 tomcat jdbc是从tomcat7开始推出的一个连接池,相比老的dbcp连接池要优秀很多,spring boot将tomcat jdbc作为默认的连接池,只要在pom.xml中引入了spring boot的jdbc组件,就会自动引入tomcat jdbc连接池. 默认参数 以下是org.apache.tomcat.jdbc.pool.PoolProperties源码,这是tomcat jdbc连接池的默认初始参数.这个类实现了一个接口PoolConfiguration,查看这个

MySql &amp; JDBC &amp; 连接池 &amp; 总结

连接池:解决资源浪费,提高代码性能. 本小节目标: 使用DBCP,C3P0连接池完成基本数据库的操作. 使用DBUtils完成CRUD的操作. 数据库连接池的解决方案是: 当应用程序启动时,系统主动建立足够的数据库连接,并将这些连接组成一个连接池.每次应用程序请求数据库连接时,无须重新打开连接,而是从连接池中取出已有的连接使用,使用完后不再关闭数据库连接,而是直接将连接归还给连接池.通过使用连接池,将大大提高程序的运行效率. 数据库连接池是Connection 对象的工程.数据库连接池的常用参数

JDBC连接池与工具类

1.连接池概述 用池来管理Connection,这样可以重复使用Connection,有了池,所以我们就不用自己来创建Connection,而是通过池来获取Connection对象,当使用完Connection后,调用Connection的close()方法也不会真的关闭Connection,而是把Connection归还给池,池就可以再利用这个Connection对象了 2.C3P0 public class Demo1 { @Test public void test() throws Ex

JDBC连接池

主要内容: 介绍数据库连接池 需要的接口和方法 实现步骤 一.数据库连接池: 1. 预先向数据库申请多个可用的数据库连接,保存到集合对象中,应用程序每次从集合对象中取出可用的数据库连接,执行数据库操作:操作完成后将连接放回集合对象.实现了数据库连接的复用. 2.数据库连接的建立是整个数据库操作中最耗时的操作,我们只做一次数据库操作就开关一次数据库连接,这样是很影响效率的     3.我们是不是可以这样,每次从某一个缓存的地方获取一个数据库连接,使用完之后再归还到那个缓存的地方,不真正意义上的关闭