利用java的可序列化IO流仿数据库原理进行CRUD操作。

最新推荐文章于 2022-10-29 12:12:04 发布

linhu007

最新推荐文章于 2022-10-29 12:12:04 发布

阅读量1.4k

点赞数

分类专栏： java基础笔记文章标签： io流操作 java

本文链接：https://blog.csdn.net/linhu007/article/details/46965263

版权

java基础笔记专栏收录该内容

47 篇文章 3 订阅

订阅专栏

1、序列化简介：

Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java对象序列化就能够帮助我们实现该功能。
使用Java对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的"状态"，即它的成员变量。由此可知，对象序列化不会关注类中的静态变量。
除了在持久化对象时会用到对象序列化之外，当使用RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化。Java序列化API为处理对象序列化提供了一个标准机制，该API简单易用，而我今天只是把序列化运用到javaWeb中实现，将序列化文件当成一个小型数据库来进行CRUD操作。

2、整体项目：

1、User.java是实现序列的对象，java规定要对某个类进行序列化必须实现Serializable接口：

package cn.bjcx.bean;

import java.io.Serializable;

public class User implements Serializable{
	private static final long serialVersionUID = 1L;
	private Integer userId;
	private String password;
	public Integer getUserId() {
		return userId;
	}
	public void setUserId(Integer userId) {
		this.userId = userId;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	//重写equal方法，对文件进行查询的时候，利用id唯一，保证对每个对象的准确性
		@Override
		public boolean equals(Object obj) {
			boolean flag = false;
			if(obj instanceof User) {
				User user = (User)obj;
				if(this.userId.equals(user.getUserId())&&this.password.equals(user.getPassword()) ) {
					flag=true;
				}
			}
			return flag;
		}
		@Override
		public String toString() {
			return "User [userId=" + userId + ", password=" + password + "]";
		}

}

2、FileObjectManager.java封装了对序列对象的基本CRUD操作

package cn.bjcx.util;


import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

import cn.bjcx.bean.User;

/**
 * 文件对象管理类
 * 
 * @author 林浩007
 * 
 */
public class FileObjectManager {

	private String filePath;

	private String fileName;

	private ObjectOutputStream oos;
	private ObjectInputStream ois;

	public FileObjectManager() {
	}

	public FileObjectManager(String filePath) {
		this.filePath = filePath;
		init(filePath);
	}

	public String getFileName() {
		return fileName;
	}

	private void init(String fileName) {
		this.fileName = fileName;
		// 对文件名分割，当分割长度为1时，则代表输入的是没有后缀的文件名，若输入的有后缀，则将后缀替换为txt
		String[] splitPath = fileName.split("\\.");
		if (splitPath.length == 1) {
			fileName += "User.txt";
		} else {
			fileName = splitPath[0] + ".txt";
		}
		try {
			open();
		} catch (IOException e) {
		}
	}
	
	/**
	 * 打开该流的输入输出
	 * 
	 * @throws IOException
	 */
	public static FileObjectManager open(String filePath) throws IOException {
		return new FileObjectManager(filePath);
	}

	/**
	 * 
	 * @param filePath
	 *            文件路径
	 * @param UserList
	 *            对象集合
	 * @param flag
	 *            是否追加添加
	 * @throws IOException
	 */
	public synchronized void save(List<User> UserList, boolean flag)
			throws IOException {
		// 改变输出文件的流的具体方式
		changeObjectOutputStream(flag);

		for (int i = 0; i < UserList.size(); i++) {
			save0(UserList.get(i));
		}
	}

	/**
	 * 将对象输出到对应的流中
	 * 
	 * @param User
	 */
	private synchronized void save0(User User) {
		try {
			oos.writeObject(User);
			oos.flush();
		} catch (IOException e1) {
		}
	}

	/**
	 * 保存单个User对象
	 * 
	 * @param filePath
	 * @param User
	 * @param flag
	 *            // 允许对象添加到之后而不是覆盖
	 * @throws IOException
	 */
	public synchronized void save(User user, boolean flag)
			throws IOException {
		// 改变输出文件的流的具体方式
		changeObjectOutputStream(flag);

		save0(user);
	}

	public synchronized User readAObject() throws IOException {
		User User = null;
		try {
			User = (User) ois.readObject();
		} catch (ClassNotFoundException e) {
			throw new IOException("读取对象出错");
		}
		return User;
	}

	/**
	 * 读出对应文件中的所有对象
	 * 
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	public synchronized List<User> read() throws IOException {
		List<User> objectList = new ArrayList<User>();
		User User = null;
		try {
			if (ois == null) {
				return objectList;
			}
			while ((User = (User) ois.readObject()) != null) {
				objectList.add(User);
			}
		} catch (EOFException e) {
		} catch (IOException e1) {
			// throw e1;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return objectList;
	}

	/**
	 * 查询此User对象是否存在
	 * 
	 * @param filePath
	 * @param User
	 * @return
	 * @throws IOException
	 */
	public synchronized User query(User User) throws IOException {
		List<User> list = this.read();
		int index = this.query0(list, User);
		if (index != -1) {
			return list.get(index);
		}
		return null;
	}

	public synchronized boolean contains(User User) throws IOException {
		List<User> list = this.read();
		int index = this.query0(list, User);
		if (index != -1) {
			return true;
		}
		return false;
	}

	/**
	 * 查询此对象在此集合中的下标
	 * 
	 * @param list
	 * @param User
	 * @return
	 */
	private synchronized int query0(List<User> list, User User) {
		for (int i = 0; i < list.size(); i++) {
			if (User.equals(list.get(i))) {
				// System.out.println(User.getVo().getUsername());
				return i;
			}
		}
		return -1;
	}

	/**
	 * 删除一个存放了User对象的list集合中的所有对象,并且返回对应数据库中的对象集合
	 * 
	 * @param filePath
	 * @param list
	 * @return
	 * @throws IOException
	 */
	public synchronized List<User> delete(List<User> list)
			throws IOException {
		// 获得此文件中所有的对象集合
		List<User> newList = new ArrayList<User>();
		List<User> objectList = this.read();
		int index = -1;
		boolean flag = false;
		// 删除对应的对象
		for (int i = 0; i < list.size(); i++) {
			if ((index = this.query0(objectList, list.get(i))) != -1) {
				flag = true;
				// 添加得到的数据
				newList.add(objectList.get(index));
				objectList.remove(index);
			}
		}
		// 再对对象进行重新保存在文件中
		if (flag) {
			try {
				this.save(objectList, false);
			} catch (IOException e) {
				throw e;
			}
		}
		return newList;
	}

//	修改某个对象
	public synchronized void  update(User User)
			throws IOException {
		// 获得此文件中所有的对象集合
		List<User> objectList = this.read();
		int index = -1;
		boolean flag = false;
		// 修改对应的对象
		if ((index = this.query0(objectList, User)) != -1) {//查找对应的对象的id
				flag = true;
				// 添加得到的数据
				objectList.remove(index);//查到相同的，将其删除
				objectList.add(User);
				this.save(objectList, false);
		}
		// 再对对象进行重新保存在文件中
	}
	/**
	 * 获取对象文件的输入流
	 * 
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	private synchronized ObjectInputStream getObjectInputStream() {
		File file = new File(filePath);
		if (!file.exists()) {
			File directions = new File(file.getAbsolutePath().substring(0,
					file.getAbsolutePath().lastIndexOf("\\")));
			directions.mkdirs();
			try {
				file.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}

		}
		try {
			InputStream is = new FileInputStream(file);
			ois = new ObjectInputStream(is);
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
		}
		return ois;
	}

	/**
	 * 获取对象文件的输出流
	 * 
	 * @param filePath
	 * @param flag
	 * @return
	 * @throws IOException
	 */
	private synchronized ObjectOutputStream getObjectOutputStream(boolean flag)
			throws IOException {
		File file = new File(filePath);
		OutputStream os = new FileOutputStream(file, flag);
		try {
			oos = FileObjectOutputStream.newInstance(file, os);
		} catch (IOException e) {
			throw new IOException("获取文件输出流错误！");
		}
		return oos;
	}

	/**
	 * 若flag传入为false时则认为需要改变文件的输出方式，为不追加的添加数据
	 * 
	 * @param flag
	 * @throws IOException
	 */
	private void changeObjectOutputStream(boolean flag) throws IOException {
		// flag不为true时，则需要的是不追加的流对象
		if (!flag) {
			if (oos != null) {
				oos.close();
			}
			oos = getObjectOutputStream(flag);
		}
	}

	public void close() throws IOException {
		if (ois != null) {
			ois.close();
			ois = null;
		}
		if (oos != null) {
			oos.close();
			oos = null;
		}
	}

	/**
	 * 打开该流的输入输出
	 * @throws IOException
	 */
	public void open() throws IOException {
		ois = getObjectInputStream();
		oos = getObjectOutputStream(true);
	}

	/**
	 * 判断流是否打开 
	 * @return
	 * @throws IOException
	 */
	public boolean isOpen() throws IOException{
		if(ois == null && oos == null) {
			return true;
		}
		return false;
	}
	
}

3、FileObjectOutputStream.java文件对象输出封装类：

package cn.bjcx.util;

import java.io.File;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

class FileObjectOutputStream extends ObjectOutputStream {
	// 定义成静态的好处
	private static File f;
	/**
	 * 初始化静态文件对象，并返回类对象
	 * 
	 * @param file
	 *            文件对象，用于初始化静态文件对象
	 * @param out
	 *            输出流
	 * @return MyObjectOutputStream
	 * @throws IOException
	 */
	public static FileObjectOutputStream newInstance(File file, OutputStream out)
			throws IOException {
		f = file;// 本方法最重要的地方：构建文件对象，是两个文件对象属于同一个
		return new FileObjectOutputStream(out, f);
	}

	@Override
	protected void writeStreamHeader() throws IOException {
		if (!f.exists() || (f.exists() && f.length() == 0)) {
			super.writeStreamHeader();
		} else {
			super.reset();
		}

	}

	public FileObjectOutputStream(OutputStream out, File f) throws IOException {
		super(out);
	}

}

3、LoginServlet.java对表单数据进行封装成对象User进行写入到user.csv中注册和验证登入

package cn.cxjy.web;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import cn.bjcx.bean.User;
import cn.bjcx.util.FileObjectManager;
public class LoginServlet extends HttpServlet {
	private static String filePath = "G:\\北京实训实例\\TrainingTest\\src\\user.csv";
	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		this.doPost(request, response);
	}
	FileObjectManager  fom = new FileObjectManager(filePath);
	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		String username = request.getParameter("username");
		String pasw = request.getParameter("pasw");
		HttpSession session = request.getSession();
		String method = request.getParameter("method");
		System.out.println("method" + method);
        //根据前台传入的method是否为空进行判断是登入还是注册		
		if (method != null) {
			if (method.equals("register")) {//method为register，那么进行注册，并将对象实现序列化
				 FileObjectManager  fom = new FileObjectManager(filePath);
				  List<User> studentList = new ArrayList<User>();
				  User user = new User();
				  user.setUserId(Integer.valueOf(request.getParameter("userId")));
				  user.setPassword(request.getParameter("pasw"));
				  studentList.add(user);
			      fom.save(studentList, true);//实现user对象的序列化，成功之后跳转到登入index.jsp页面
			      request.getRequestDispatcher("index.jsp").forward(
							request, response);
			} else {
				session.invalidate();
				response.sendRedirect("index.jsp");
			}
		} else {
			//反序列化创建对象，查询用户登入的用户名和密码是否正确，正确就登入成功
			if (judgeUser(username, pasw)) {
				session.setAttribute("username", username);
				request.getRequestDispatcher("demo1/successful.jsp").forward(
						request, response);
			} else {
				request.getRequestDispatcher("demo1/error.jsp").forward(
						request, response);
			}
		}

	}
//判断用户名和密码
	private boolean judgeUser(String username,String pasw) throws IOException{
		boolean flag = false;
		User user = new User();
		user.setUserId(Integer.valueOf(username));
		System.out.println(username);
		user.setPassword(pasw);
		List<User> list = fom.read();//查询
		   for(int i=0;i<list.size();i++){
			  if(list.get(i).equals(user)){
				  flag=true;
			  }
		   }
		return flag;
	}

}

4、登入与注册页面以及判断用户是否登入成功：

index.sp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
	String path = request.getContextPath();
	String basePath = request.getScheme() + "://"
			+ request.getServerName() + ":" + request.getServerPort()
			+ path + "/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>序列化操作</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<script language="javascript" src="demo1/judge.js"></script>
</head>
<body>
<!-- 登入页面 -->
<%
session.invalidate();
 %>
	<center>
		<h1>实训第一次作业---》javaScript验证</h1>
		  <form action="LoginServlet" οnsubmit="check()"
			method="post"> 
			<table>
				<tr>
					<th>输入姓名：</th>
					<th><input type="text" name="username" id="username" />
					</th>
				</tr>
				<tr>
					<th>输入密码：</th>
					<th><input type="password" name="pasw" id="pasw" />
					</th>
				</tr>
				<tr>
					<th><a href="demo1/Registered.jsp">注册</a></th>
					<th><input type="submit" value="验证"  onClick="check()"/>
						    <input type="reset" value="重置" />
					</th>
				</tr>
			</table>
		</form>
	</center>
</body>
</html>

Registered.jsp：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">  
    <title>商品注册</title>
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
  </head>
  <body>
    <form action="LoginServlet?method=register" method="post">
    <table>
    <tr>
    <th>用户账号</th>
     <tr><input type="text" name="userId" id="userId" /></tr>
    </tr>
    <tr>用户密码</tr>
    <tr><input type="password" name="pasw" id="pasw" /></tr>
    <tr></tr>
    <tr><input type="submit" value="注册"/></tr>
    </table>
    </form>
  </body>
</html>

successful.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
	String path = request.getContextPath();
	String basePath = request.getScheme() + "://"
			+ request.getServerName() + ":" + request.getServerPort()
			+ path + "/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>结果</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->
</head>
<body>
	<center>
		<%
			/* HttpSession session = request.getSession(); */
			Object username = session.getAttribute("username");
			if (username == null) {
				username = request.getParameter("username");
				session.setAttribute("username", username);
			} else {
		%>
		<h1>您已经登入过了</h1>
		<%
			}
		%>
		<br> 姓名：<%=session.getAttribute("username")%>
		<a href="index.jsp">注销</a>
	</center>
</body>
</html>

judge.js:

function check() {
	var username = document.getElementById("username").value;
	var pasw = document.getElementById("pasw").value;
	if (username == "" || pasw == "") {
		alert("用户名和密码不能为空");
		return flase;
	} else {
		if (username.indexOf("#") != -1 || username.indexOf("*") != -1) {
			alert("包含非法字符#或者*，请从新验证");
			return flase;
		}
	}
	return true;
}

以上代码是利用序列化进行注册和登入验证的实例，修改和删除实例在FileObjectManager.java中都有封装好的方法，直接调用即可。