java学生信息管理系统设计（2）_java

本例的学生信息添加进入数据库的事务(可以提交事务,事务回滚,用本地线程完善)

主页面index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
 <head>

 <title>学生信息管理</title>
 </head>

 <body>
 <a href='<c:url value="/query"/>?cmd=query'>查看学生信息</a>
 <br><br>
 <!--
 <a href="<c:url value='/StudServlet?cmd=save' />">学生信息添加</a>
  -->
 <h2>学生信息添加</h2>
 <form action='<c:url value="/query"/>?cmd=add' method="post">
  姓名:<input type="text" name="name"/><br><br>

  <fieldset style="border: solid;border-color: red;width: 250px;">
   <legend>图书1</legend>
    书名:<input type="text" name="book"/><br><br>
    价格:<input type="text" name="price"/>
  </fieldset>
  <br>
  <fieldset style="border: solid;border-color:green;width: 250px;">
   <legend>图书2</legend>
    书名:<input type="text" name="book"/><br><br>
    价格:<input type="text" name="price"/>
  </fieldset>
  <br><br>
  <input type="submit" value="提交"/><br><br>
 </form>
 </body>
</html>

工具包

获取数据库连接的工具ConnUtils5.java

package cn.hncu.utils;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class ConnUtils5 {

 //本地线程管理对象，用于实现: 同一个线程获取的连接是同一个
 private static ThreadLocal< Connection> t=new ThreadLocal<Connection>();
 private final static List<Connection> pool=new ArrayList<Connection>();
 private static int SIZE;//由资源文件读取
 private ConnUtils5(){

 }
 static{
  Properties p=new Properties();
  try {
   //下面这种方式在纯Java项目中可以读取到classpath下的资源文件，但无法读取JavaEE项目的。因为Tomcat把系统的默认类加载器改了
   //p.load( ClassLoader.getSystemClassLoader().getSystemResourceAsStream("jdbc.properties"));
//   p.load(ClassLoader.getSystemResourceAsStream("jdbc.properties"));

   //读取Web项目的classpath下的资源文件,用这个可以
   p.load(ConnUtils3.class.getClassLoader().getResourceAsStream("jdbc.properties"));
   String driver=p.getProperty("driver");
   String url=p.getProperty("url");
   String name=p.getProperty("username");
   String pwd=p.getProperty("password");
   String ssize=p.getProperty("size");
   SIZE=Integer.parseInt(ssize);
   Class.forName(driver);
   for(int i=0;i<SIZE;i++){
    final Connection con=DriverManager.getConnection(url,name,pwd);
    System.out.println("con=="+con);
    //更改conn.close()方法
    //用代理模式生成一个增强版的conn对象，把它的close()方法拦截更改掉
    Object nCon=Proxy.newProxyInstance(
      ConnUtils3.class.getClassLoader(),
      // conn.getClass().getInterfaces(),
      //后面这种方式不行,应该是驱动中的实现类和我们当前程序不在同一空间(类加载器不同)
      new Class[]{Connection.class},
      new InvocationHandler() {
       @Override
       public Object invoke(Object proxy, Method method, Object[] args)
         throws Throwable {
        if(method.getName().equals("close")){
         System.out.println("还回一个链接："+(Connection)proxy);
         pool.add((Connection)proxy);
         return null;
        }
        return method.invoke(con, args);
       }
    });
    pool.add((Connection)nCon);
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
 public static synchronized Connection getConnection(){
  //先从t中拿，如果有就拿出去，如果没有再到池中拿且把该对象放到t中
  Connection con=t.get();
  if(con==null){

   if(pool.size()<=0){
    System.out.println("池中连接没有了...");
    try {
     Thread.sleep(1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    return getConnection();
   }
   con=pool.remove(0);
   t.set(con);//放到t中
  }

  return con;//拿一个移一个
 }

}

代理

package cn.hncu.utils;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;

public class TxProxy implements InvocationHandler {

 private Object srcObj=null;

 private TxProxy(Object srcObj) {
  this.srcObj = srcObj;
 }

 public static Object getProxy(Object srcObj){
  System.out.println("srcObj:"+srcObj);
  Object newObj=Proxy.newProxyInstance(
    TxProxy.class.getClassLoader(),
    srcObj.getClass().getInterfaces(),
    new TxProxy(srcObj));
  System.out.println("newObj:"+newObj);
  return newObj;
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  Connection con=null;
  Object returnObj=null;
  try {
   con=ConnUtils5.getConnection();
   System.out.println("invoke拿到一个链接："+con);
   con.setAutoCommit(false);

   returnObj=method.invoke(srcObj, args);

   System.out.println("提交一个事务...");
   con.commit();
  } catch (Exception e) {
   try {
    System.out.println("回滚一个事务...");
    con.rollback();
   } catch (SQLException e1) {
    e1.printStackTrace();
   }
  }finally{
   try {
    con.setAutoCommit(true);
    con.close();
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }
  return returnObj;
 }

}

代理2:不需要强转,但是代理了所有

package cn.hncu.utils;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;

public class TxProxy2 implements InvocationHandler {

 private Object srcObj=null;

 private TxProxy2(Object srcObj) {
  this.srcObj = srcObj;
 }

 public static<T> T getProxy(Class<T> c){
  Object obj=null;
  try {
   obj = c.newInstance();
  } catch (Exception e) {
   e.printStackTrace();
  }
  Object newObj=Proxy.newProxyInstance(
    TxProxy2.class.getClassLoader(),
    c.getInterfaces(),
    new TxProxy2(obj));
  return (T) newObj;
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  Connection con=null;
  Object returnObj=null;
  try {
   con=ConnUtils5.getConnection();
   System.out.println("invoke拿到一个链接："+con);
   con.setAutoCommit(false);

   returnObj=method.invoke(srcObj, args);

   System.out.println("提交一个事务...");
   con.commit();
  } catch (Exception e) {
   try {
    System.out.println("回滚一个事务...");
    con.rollback();
   } catch (SQLException e1) {
    e1.printStackTrace();
   }
  }finally{
   try {
    con.setAutoCommit(true);
    con.close();
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }
  return returnObj;
 }

}

注解

package cn.hncu.utils;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(value=ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Transaction {

}

代理3:用注解实现需要事务则用事务

package cn.hncu.utils;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;

public class TxProxy3 implements InvocationHandler {

 private Object srcObj=null;

 private TxProxy3(Object srcObj) {
  this.srcObj = srcObj;
 }

 public static<T> T getProxy(T srcObj){
  Object newObj=Proxy.newProxyInstance(
    TxProxy3.class.getClassLoader(),
    srcObj.getClass().getInterfaces(),
    new TxProxy3(srcObj));
  return (T) newObj;
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  /* 这种方式来实现只拦截指定的方法
  if(method.getName().equals("close")){
   ...拦截
  }else{
   return method.invoke(srcObj, args);
  }
  */
  if(method.isAnnotationPresent(Transaction.class)){

   Connection con=null;
   Object returnObj=null;
   try {
    con=ConnUtils5.getConnection();
    System.out.println("invoke拿到一个链接："+con);
    con.setAutoCommit(false);
    //真正的业务代码，放行
    returnObj=method.invoke(srcObj, args);

    System.out.println("提交一个事务...");
    con.commit();
   } catch (Exception e) {
    try {
     System.out.println("回滚一个事务...");
     con.rollback();
    } catch (SQLException e1) {
     e1.printStackTrace();
    }
   }finally{
    try {
     con.setAutoCommit(true);
     con.close();
    } catch (SQLException e) {
     e.printStackTrace();
    }
   }
   return returnObj;
  }else{
   System.out.println("不存在事务注解，直接放行!");
   return method.invoke(srcObj, args);
  }
 }

}

资源文件jdbc.properties

##MySQL
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/hncu?useUnicode=true&characterEncoding=utf-8
username=root
password=1234
size=3
##Oracle
#driver=oracle.jdbc.driver.OracleDriver
#url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
#username=scott
#password=tiger

stud层的servlet层–QueryServlet.java

package cn.hncu.stud.servlet;

import java.io.IOException;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import cn.hncu.domain.Book;
import cn.hncu.domain.Stud;
import cn.hncu.stud.service.IStudService;
import cn.hncu.stud.service.StudServiceImpl;
import cn.hncu.utils.TxProxy3;

public class QueryServlet extends HttpServlet {

 //注入
 //1.
// IStudService service=(IStudService) TxProxy.getProxy(new StudServiceImpl());
 //2.
// IStudService service=TxProxy2.getProxy(StudServiceImpl.class);
 //3.
 IStudService service=TxProxy3.getProxy(new StudServiceImpl());
 public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {

  doPost(request, response);
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  String cmd=request.getParameter("cmd");
  System.out.println("cmd:"+cmd);
  if("query".equals(cmd)){
   query(request, response);
  }else if("add".equals(cmd)){
   add(request, response);
  }
 }

 public void query(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  System.out.println("service:"+service);
  List<Map<String, String>> studs=service.query();
  request.setAttribute("studs", studs);
  request.getRequestDispatcher("/jsps/show.jsp").forward(request, response);
 }
 public void add(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  //1收集参数 2组织参数(id字段留到dao中去补)
  String name[]=request.getParameterValues("name");
  Stud s=new Stud();
  s.setName(name[0]);
  //图书信息
  String books[]=request.getParameterValues("book");
  //防护一下 ---价格的防护应该也要写，这里我们偷懒了
  if(books==null||books.length<=0){
   return;
  }
  String prices[]=request.getParameterValues("price");
  for(int i=0;i<books.length;i++){
   Book b=new Book();
   b.setName(books[i]);
   b.setPrice(Double.parseDouble(prices[i]));
   //※完成两个值对象的“一对多”关系的数据封装
   s.getBooks().add(b);//一方
   b.setS(s);//多方
  }
  //3调用service层
  try {
   service.save(s);
  } catch (Exception e) {
   //导向失败页面
  }

 }

}

stud层的service层–
接口：

package cn.hncu.stud.service;

import java.util.List;
import java.util.Map;

import cn.hncu.domain.Stud;
import cn.hncu.utils.Transaction;

public interface IStudService {

 public List<Map<String, String>> query();

 //注意，注解只有放在接口才有用,,,,写在实现类中的方法无效(不会决定开启事务)
 @Transaction
 public void save(Stud stud) throws Exception ;
}

实现类

package cn.hncu.stud.service;

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

import cn.hncu.domain.Stud;
import cn.hncu.stud.dao.BookDAO;
import cn.hncu.stud.dao.BookJdbcDao;
import cn.hncu.stud.dao.StudDAO;
import cn.hncu.stud.dao.StudJdbcDAO;
import cn.hncu.utils.ConnUtils5;

/*我们以后开发时通常都要采用一个dao独立操作一个表,系统中有几个实体表就写几个dao，
 * 以后框架都是这么干的，我们也要这样做，因为架构好！
 *
 * 采用事务的场合:
 * 1、如果只有一个dao，但要执行多条sql语句且涉及增删改，则要开启事务
 * 2、如果一个service调用多个dao，通常也要开启事务。
 */
public class StudServiceImpl implements IStudService {

 //注入
 StudDAO dao_stud=new StudJdbcDAO();
 BookDAO dao_book=new BookJdbcDao();
 @Override
 public List<Map<String, String>> query() {
  return dao_stud.query();
 }
 @Override
 public void save(Stud stud) throws Exception {
  dao_stud.save(stud);
  dao_book.save(stud.getBooks());
 }

}

stud层的dao层–
Stud接口–分离式做法,一个表对应一个dao,为框架做准备

package cn.hncu.stud.dao;

import java.util.List;
import java.util.Map;

import cn.hncu.domain.Stud;

public interface StudDAO {

 public List<Map<String, String>> query();
 public void save(Stud stud) throws Exception;
}

Stud实现类

package cn.hncu.stud.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import cn.hncu.domain.Book;
import cn.hncu.domain.Stud;
import cn.hncu.utils.ConnUtils3;

public class StudJdbcDAO implements StudDAO {

 @Override
 public List<Map<String, String>> query() {
  List<Map<String, String>> list=new ArrayList<Map<String,String>>();
  //一个map就是一行数据， List<Map>就是整个数据表
  Connection con=null;
  try {
   con=ConnUtils3.getConnection();
   Statement st=con.createStatement();
   String sql="select * from stud";
   ResultSet rs=st.executeQuery(sql);
   while(rs.next()){
    Map<String,String> m=new HashMap<String, String>();
    m.put("id", (String) rs.getObject(1));
    m.put("name", (String) rs.getObject(2));
    list.add(m);
   }
   rs.close();
   st.close();
  } catch (SQLException e) {
   e.printStackTrace();
  }finally{
   try {
    con.close();
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }

  return list;
 }

 @Override
 public void save(Stud stud) throws Exception {
  Connection con=ConnUtils3.getConnection();
  System.out.println("拿到一个链接："+con);
  String sql="insert into stud values(?,?)";
  String uuid=UUID.randomUUID().toString().replace("-", "");
  PreparedStatement pst=con.prepareStatement(sql);
  stud.setId(uuid);//为了"多方"即book能够拿到"一方"的id，专门补的
  pst.setString(1, uuid);
  pst.setString(2, stud.getName());
  System.out.println("1:"+uuid+",2:"+stud.getName());
  pst.executeUpdate();
//  con.close();//拿到同一个con,这里就不需要关了
 }

}

Book接口

package cn.hncu.stud.dao;

import java.util.List;

import cn.hncu.domain.Book;

public interface BookDAO {

 public void save(List<Book> books) throws Exception;
}

Book实现类

package cn.hncu.stud.dao;

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

import cn.hncu.domain.Book;
import cn.hncu.utils.ConnUtils3;

public class BookJdbcDao implements BookDAO {

 @Override
 public void save(List<Book> books) throws Exception {
  Connection con=ConnUtils3.getConnection();
  System.out.println("拿到一个链接："+con);
  String sql="insert into book(name,price,studid) values(?,?,?)";
  PreparedStatement pst=con.prepareStatement(sql);
  for(Book b:books){
   pst.setString(1, b.getName());
   pst.setDouble(2, b.getPrice());
   pst.setObject(3, "12132312");//异常(故意给一个不存在的外键字段，以测试事务回滚)--测事务回滚
//   pst.setObject(3, b.getS().getId());
   System.out.println("1:"+b.getName()+",2:"+b.getPrice()+",3:"+b.getS().getId());
   pst.addBatch();//添加到批处理
  }
  pst.executeBatch();//执行批处理

//  con.close();//这里拿到同一个con，这里不需要关

 }

}

值对象
Stud对象

package cn.hncu.domain;

import java.util.ArrayList;
import java.util.List;
/*
 * 一对多中的 “一”方 值对象的建法
 */
public class Stud {

 private String id;
 private String name;
 //※专为“多”方添加一个集合---体现多表中的“一对多关系”
 private List<Book> books=new ArrayList<Book>();//注意，该集合要在构造时或之前就new出来。
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }

 public List<Book> getBooks() {
  return books;
 }
 public void setBooks(List<Book> books) {
  this.books = books;
 }
 @Override
 public String toString() {
  return "id=" + id + "," + name + "," + books;
 }

}

Book对象

package cn.hncu.domain;
/*
 * 一对多中的 “多”方 值对象的建法
 */
public class Book {

 private Integer id;
 //基本数据类型全部用包装类的声明，为以后使用框架做技术准备---包装类能够兼容框架(因为一般框架都会使用类反射)
 private String name;
 private Double price;
 //※专为“一”方添加一个对象类型的变量(注意，不用studid)---体现多表中的“一对多关系”
 private Stud s;//设置主人
 //private String studid;//★★不要这样设
 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 Double getPrice() {
  return price;
 }
 public void setPrice(Double price) {
  this.price = price;
 }
 public Stud getS() {
  return s;
 }
 public void setS(Stud s) {
  this.s = s;
 }
 /*
  * 多表关联时的toString()方法要注意一个陷阱，就是一方输出另一方，同时另一方又反过来输出前一方，形成无穷递归！
  */
 @Override
 public String toString() {
  return "id=" + id + "," + name + "," + price;//这里不能输出Stud对象，否则无穷递归
 }

}

显示学生信息页面jsps/show.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
 <head>

 <title>学生信息管理</title>
 </head>

 <body>
 <h2>学生信息</h2>
 <c:forEach items="${studs}" var="x">
 ${x.id},${x.name}<br/>
 </c:forEach>
 </body>
</html>

效果图：

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索java学生信息管理
， java管理系统
java学生管理系统
java学生管理系统设计、java学生管理系统、学生成绩管理系统java、java学生信息管理系统、javaweb学生选课系统，以便于您获取更多的相关知识。

时间： 2024-09-20 11:49:50

java学生信息管理系统设计（2）_java的相关文章

java学生信息管理系统设计_java

本例的学生信息添加进入数据库的事务(可以提交事务,事务回滚,用本地线程完善) 主页面index.jsp <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <htm

Java+Mysql学生管理系统源码_java

最近正在学java和数据库,想起以前写的学生管理系统,都是从网上下载,敷衍了事.闲来无事,也就自己写了一个,不过功能实现的不是很多.  开发语言:java: 开发环境:Mysql, java: 开发工具:eclipse 开发此案例,首先得在电脑上有java开发环境和Mysql, java开发环境与Mysql的搭建,就不再叙述了,如果需要,请联系我最下面的联系方式:dingyelf@aliyun.com  此次系统比较简易:数据库中只有一个表:stu;功能:能够对学生增加.删除.修改.开发步骤: 

java开发就业信息管理系统_java

本文实例为大家分享了java就业信息管理平台开发案例,供大家参考,具体内容如下 可查询公司信息,学生信息,班级信息,针对学生就业与否信息的统计,老师和管理员登录后的权限不同等 就业信息管理平台想要实现的是各个班级的学生就业情况,数据库里建有6张表,分别是班级,公司,职位,学生,登录用户. 其中就业信息在界面上显示的内容是学生信息和职位的组合,在jsp页面中是拼接来实现,如果这个学生找到工作则需要填写就业信息,否则空着.如就业截图. 在企业信息中,需要实现的功能是首先有计划招聘时间,实际招聘时间,

Java学生成绩管理系统源代码

源代码 import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.InputStreamReader;import java.io.Pr

java学生信息管理系统在删除信息的时候遇到了问题，代码如下，求大神。

问题描述 java学生信息管理系统在删除信息的时候遇到了问题,代码如下,求大神. 这是代码 主类 public class Main { public static void main(String[] args) throws FileNotFoundException { int i = 0; Manage m=new Manage(); Scanner sc=new Scanner(System.in); ArrayList List=new ArrayList<Student>();

链表-请教：（C语言学生信息管理）程序函数里好像直接跳过了某一段代码执行

问题描述 请教:(C语言学生信息管理)程序函数里好像直接跳过了某一段代码执行 void Student_Searchself(STUDENT *head) //此函数是为了显示学生的各科成绩和各科排名 //(head)存储学生成绩的链表头指针{STUDENT *p*m*e*y*l;STUDENT *p1*p2*p3*p4;char s[6];system(""cls"");printf(""请输入本人学号来查找n"");sca

java学生成绩管理系统

问题描述 java学生成绩管理系统 要求:编写学生成绩管理系统:有5个学生,每个学生有2门课成绩,从键盘上输入以上数据(学生信息包括学号.姓名,以及2门课成绩),保存在一个文本文件中.计算出每个学生的总成绩,并将学生数据(包括学生2门课的总成绩)按总分由高到低排序后保存到磁盘文件sort.txt中.统计平均成绩,不及格比例,及格比例.优良中所占比例.要求用菜单方式选择功能. 解决方案 这应该是个毕业设计,自己完成吧~ 呵呵!!!!! 完全没时间帮你弄这~ 解决方案二: 课程设计,还是自己做吧.

c#做的一个学生信息管理窗体程序与ACCESS连接，怎么在状态栏显示我存的人数

问题描述 c#做的一个学生信息管理窗体程序与ACCESS连接,怎么在状态栏显示我存的人数 求帮忙,谢谢啦 c#做的一个学生信息管理窗体程序与ACCESS连接,怎么在状态栏显示我存的人数 解决方案 access 中读取出来 然后 赋值给 状态栏中的控件

基于struts+hibernate的学生考勤系统设计

问题描述 请问谁有"基于struts+hibernate的学生考勤系统设计"的源码和设计方案呢?能后给小弟发一份..最近在学习jsp网站的开发,想做一个这样的网站..想学习借鉴下别人怎么做的...我的邮箱是"yongliuaaa@163.com"...灰常感谢! 解决方案 解决方案二:这个网上多,可以去搜搜类似的网站源码看看.解决方案三:网上搜以下多很的....解决方案四:我在网上收索过了,好多都下不下来的...所以看看大家有没有,能给我传一个最好..谢谢解决方案五