七月472

学生系统(mySQL)

文章目录

一、所用工具

二、数据库界面

三、底层代码

util包--连接数据库

entity包 --实体类

dao --方法类

学生教师爱好班级

biz --业务逻辑层

学生教师爱好班级

servlet

绑值&模糊查询增加修改删除

四、界面

index.jsp主界面

add.jsp增加

update.jsp修改

嗨~

一、所用工具

数据库：MySQL

开发工具：eclipse

系统需求：1️⃣使用MySQL建立教员表、学生表、班级表、爱好表；

2️⃣要求带条件进行查询（使用下拉框&复选框&无刷新分页）；

3️⃣新增功能；

4️⃣修改功能(界面样式可与新增界面一致，但教员以及教员所在班级的下拉框，要求默认选中对应的值，学生的爱好有哪些，那么默认勾选上对应的爱好复选框)；

5️⃣删除功能，删除带提示

二、数据库界面

班级表：

爱好表：

学生表：

教师表：

三、底层代码

com.hemingxiang.util包

#oracle9i
#driver=oracle.jdbc.driver.OracleDriver
#url=jdbc:oracle:thin:@localhost:1521:orcl
#user=scott
#pwd=123
 
 
#sql2005
#driver=com.microsoft.sqlserver.jdbc.SQLServerDriver
#url=jdbc:sqlserver://localhost:1433;DatabaseName=test1
#user=sa
#pwd=123
 
 
#sql2000
#driver=com.microsoft.jdbc.sqlserver.SQLServerDriver
#url=jdbc:microsoft:sqlserver://localhost:1433;databaseName=unit6DB
#user=sa
#pwd=888888
 
 
#mysql
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/0614?useUnicode=true&characterEncoding=UTF-8&useSSL=false
user=root
pwd=123456

package com.hemingxiang.util;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
 
/**
 * 提供了一组获得或关闭数据库对象的方法
 * 
 */
public class DBHelper {
	private static String driver;
	private static String url;
	private static String user;
	private static String password;
 
	static {// 静态块执行一次，加载 驱动一次
		try {
			InputStream is = DBHelper.class
					.getResourceAsStream("config.properties");
 
			Properties properties = new Properties();
			properties.load(is);
 
			driver = properties.getProperty("driver");
			url = properties.getProperty("url");
			user = properties.getProperty("user");
			password = properties.getProperty("pwd");
 
			Class.forName(driver);
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}
	}
 
	/**
	 * 获得数据连接对象
	 * 
	 * @return
	 */
	public static Connection getConnection() {
		try {
			Connection conn = DriverManager.getConnection(url, user, password);
			return conn;
		} catch (SQLException e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}
	}
 
	public static void close(ResultSet rs) {
		if (null != rs) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			}
		}
	}
 
	public static void close(Statement stmt) {
		if (null != stmt) {
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			}
		}
	}
 
	public static void close(Connection conn) {
		if (null != conn) {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			}
		}
	}
 
	public static void close(Connection conn, Statement stmt, ResultSet rs) {
		close(rs);
		close(stmt);
		close(conn);
	}
 
	public static boolean isOracle() {
		return "oracle.jdbc.driver.OracleDriver".equals(driver);
	}
 
	public static boolean isSQLServer() {
		return "com.microsoft.sqlserver.jdbc.SQLServerDriver".equals(driver);
	}
	
	public static boolean isMysql() {
		return "com.mysql.jdbc.Driver".equals(driver);
	}
 
	public static void main(String[] args) {
		Connection conn = DBHelper.getConnection();
		DBHelper.close(conn);
		/*System.out.println("isOracle：" + isOracle());
		System.out.println("isSQLServer：" + isSQLServer());*/
		System.out.println("isMysql：" + isMysql());
		System.out.println("数据库连接(关闭)成功");
	}
}

com.hemingxiang.entity包 (实体类)

package com.hemingxiang.entity;
 
import java.io.Serializable;
 
/**
 * 实体类：教师类
 * @author hmx
 *
 */
public class Teacher implements Serializable{
	//防止序列化与反序列化
	private static final long serialVersionUID = 1L;
	private int tid;//教员编号
	private String tname;//教员姓名
	private Class c;//所教班级
	public int getTid() {
		return tid;
	}
	public void setTid(int tid) {
		this.tid = tid;
	}
	public String getTname() {
		return tname;
	}
	public void setTname(String tname) {
		this.tname = tname;
	}
	public Class getC() {
		return c;
	}
	public void setC(Class c) {
		this.c = c;
	}
	
	public Teacher() {
		// TODO Auto-generated constructor stub
	}
	public Teacher(int tid, String tname, Class c) {
		this.tid = tid;
		this.tname = tname;
		this.c = c;
	}
	
	public Teacher( String tname, Class c) {
		this.tname = tname;
		this.c = c;
	}
	@Override
	public String toString() {
		return "Teacher [tid=" + tid + ", tname=" + tname + ", c=" + c + "]";
	}
	
}

package com.hemingxiang.entity;
 
import java.io.Serializable;
import java.util.List;
 
/**
 * 实体类：学生类
 * @author hmx
 *
 */
public class Student implements Serializable{
	//防止序列化与反序列化
	private static final long serialVersionUID = 1L;
	private int sid;//学生编号
	private String sname;//学生姓名
	private Class c;//班级
	private Habby h;//爱好
	private Teacher tea;//老师
	private String ss;
	private List ls;
	
	
	public String getSs() {
		return ss;
	}
	public void setSs(String ss) {
		this.ss = ss;
	}
	public List getLs() {
		return ls;
	}
	public void setLs(List ls) {
		this.ls = ls;
	}
	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public Class getC() {
		return c;
	}
	public void setC(Class c) {
		this.c = c;
	}
	public Habby getH() {
		return h;
	}
	public void setH(Habby h) {
		this.h = h;
	}
	public Teacher getTea() {
		return tea;
	}
	public void setTea(Teacher tea) {
		this.tea = tea;
	}
	
	public Student() {
		// TODO Auto-generated constructor stub
	}
	public Student(int sid, String sname, Class c, Habby h, Teacher tea, String ss, List ls) {
		this.sid = sid;
		this.sname = sname;
		this.c = c;
		this.h = h;
		this.tea = tea;
		this.ss = ss;
		this.ls = ls;
	}
	public Student(int sid, String sname, Class c,Teacher tea, String ss) {
		this.sid = sid;
		this.sname = sname;
		this.c = c;
		this.tea = tea;
		this.ss = ss;
	}
	@Override
	public String toString() {
		return "Student [sid=" + sid + ", sname=" + sname + ", c=" + c + ", h=" + h + ", tea=" + tea + ", ss=" + ss
				+ ", ls=" + ls + "]";
	}
	
}

package com.hemingxiang.entity;
 
import java.io.Serializable;
 
/**
 * 实体类：爱好类
 * @author hmx
 *
 */
public class Habby implements Serializable{
	//防止序列化与反序列化
	private static final long serialVersionUID = 1L;
	private String hid;//爱好编号
	private String hname;//爱好名称
	
	public String getHid() {
		return hid;
	}
	public void setHid(String hid) {
		this.hid = hid;
	}
	public String getHname() {
		return hname;
	}
	public void setHname(String hname) {
		this.hname = hname;
	}
	
	public Habby() {
		// TODO Auto-generated constructor stub
	}
	public Habby(String hid, String hname) {
		this.hid = hid;
		this.hname = hname;
	}
	
	public Habby( String hname) {
		this.hname = hname;
	}
	@Override
	public String toString() {
		return "Habby [hid=" + hid + ", hname=" + hname + "]";
	}
	
	
	
}

package com.hemingxiang.entity;
 
import java.io.Serializable;
 
/**
 * 实体类：班级类
 * @author hmx
 *
 */
public class Class implements Serializable{
	//防止序列化与反序列化
	private static final long serialVersionUID = 1L;
	private  int cid;//班级编号
	private String cname;//班级姓名
	
	public int getCid() {
		return cid;
	}
	public void setCid(int cid) {
		this.cid = cid;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}
	
	public Class() {
		// TODO Auto-generated constructor stub
	}
	public Class(int cid, String cname) {
		this.cid = cid;
		this.cname = cname;
	}
	
	public Class(String cname) {
		this.cname = cname;
	}
	@Override
	public String toString() {
		return "Class [cid=" + cid + ", cname=" + cname + "]";
	}
	
}

com.hemingxiang.dao (dao方法)

学生

package com.hemingxiang.dao;
 
import java.util.List;
 
import com.cdl.entity.Student;
/**
 * 数据库访问层接口
 * @author hmx
 *
 */
public interface IStuDao {
	
	/**
	 * 查询单个
	 * @param sid 学生编号
	 * @return 学生对象
	 */
	public Student getStu(int sid) ;
	
	
	/**
	 * 查询所有
	 * @return 查询的结果集合
	 */
	public List getAll();
	
	/**
	 * 模糊查询
	 * @param colName 要查询的列名
	 * @param str 关键字
	 * @return 对象
	 */
	public List getMH(String ctr,String htr, String str,int pageIndex,int pageSize);
	
	/**
	 * 增加学生
	 * @param stu 学生对象
	 * @return 影响行数
	 */
	public int addStu(Student stu);
	
	/**
	 * 删除学生
	 * @param sid 学生编号
	 * @return 影响行数
	 */
	public int delStu(int sid);
	
	/**
	 * 修改学生 
	 * @param stu 要修改的对象
	 * @param sid 学生编号
	 * @return 影响行数
	 */
	public int upStu(Student stu,int sid);
	
	/**
	 * 总行数
	 * @return 行数
	 */
	public int getRows(String str);
	
	
}

package com.hemingxiang.dao;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
 
import com.hemingxiang.entity.Class;
import com.hemingxiang.entity.Habby;
import com.hemingxiang.entity.Student;
import com.hemingxiang.util.DBHelper;
 
/**
 * 数据库访问层
 * @author hmx
 *
 */
public class StuDao implements IStuDao{
	
	//三兄弟
	Connection con = null;
	PreparedStatement ps =null;
	ResultSet rs = null;
	
	
	public Student getStu(int sid) {
		Student stu = new Student();
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "select * from tb_stu where sid=?";
			//获得执行对象
			ps=con.prepareStatement(sql);
			//给占位符赋值
			ps.setInt(1, sid);
			//给rs赋值
			rs=ps.executeQuery();
			//判断
			if(rs.next()) {
				stu.setSid(rs.getInt(1));
				stu.setSname(rs.getString(2));
				stu.setC(new ClassDao().getClz(rs.getInt(3)));
				//stu.setH(new HobbyDao().getHob(rs.getInt(4)));
				stu.setSs(rs.getString(4));
				stu.setTea(new TeaDao().getTea(rs.getInt(5)));
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			DBHelper.close(con, ps, rs);
		}
		return stu;
	}
	
	
	@Override
	public List getAll() {
		List ls = new ArrayList();
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "select * from tb_stu";
			//获得执行对象
			ps=con.prepareStatement(sql);
			//给集合赋值
			rs=ps.executeQuery();
			//遍历
			while(rs.next()) {
				List list = new ArrayList<>();
				//实例化一个对象
				Student stu = new Student();
				stu.setSid(rs.getInt(1));
				stu.setSname(rs.getString(2));
				stu.setC(new ClassDao().getClz(rs.getInt(3)));
				//stu.setH(new HobbyDao().getHob(rs.getInt(4)));
				//分割
				String hob = rs.getString(4);
				//System.out.println(rs.getString(4));
				//用逗号分割
				String [] ss = hob.split(",");
				for (String so : ss) {
					IHobbyDao ihd = new HobbyDao();
					Habby h = ihd.getHob(Integer.parseInt(so));
					list.add(h);
				}
				stu.setLs(list);
				stu.setTea(new TeaDao().getTea(rs.getInt(5)));
				//加进去
				ls.add(stu);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		finally {
			DBHelper.close(con, ps, rs);
		}
		return ls;
	}
 
	@Override
	public List getMH(String ctr, String htr,String str,int pageIndex,int pageSize) {
		List ls = new ArrayList<>();
		int a = (pageIndex-1)*pageSize;
		int b = pageSize;
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "select * from tb_stu where hid like '%"+htr+"%' and tid like '%"+str+"%' and cid like '%"+ctr+"%' limit ?,?";
			//获得执行对象
			ps=con.prepareStatement(sql);
			ps.setInt(1, a);
			ps.setInt(2, b);
			//给集合赋值
			rs=ps.executeQuery();
			//遍历
			if(rs.next()) {
				List list = new ArrayList<>();
				//实例化一个对象
				Student stu = new Student();
				stu.setSid(rs.getInt(1));
				stu.setSname(rs.getString(2));
				stu.setC(new ClassDao().getClz(rs.getInt(3)));
				//stu.setH(new HobbyDao().getHob(rs.getInt(4)));
				//分割
				String hob = rs.getString(4);
				//System.out.println(rs.getString(4));
				//用逗号分割
				String [] ss = hob.split(",");
				for (String so : ss) {
					IHobbyDao ihd = new HobbyDao();
					//调用单个查询方法
					Habby h = ihd.getHob(Integer.parseInt(so));
					list.add(h);
				}
				stu.setLs(list);
				stu.setTea(new TeaDao().getTea(rs.getInt(5)));
				//加进去
				ls.add(stu);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		finally {
			DBHelper.close(con, ps, rs);
		}
		return ls;
	}
 
	@Override
	public int addStu(Student stu) {
		int n = 0;
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "insert into tb_stu(sid,sname,cid,hid,tid) values(?,?,?,?,?)";
			//获得执行对象
			ps=con.prepareStatement(sql);
			//给占位符赋值
			ps.setInt(1, stu.getSid());
			ps.setString(2, stu.getSname());
			ps.setInt(3,stu.getC().getCid());
			ps.setString(4, stu.getSs());
			ps.setInt(5,stu.getTea().getTid());
			//给n赋值
			n=ps.executeUpdate();
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			DBHelper.close(con, ps, rs);
		}
		return n;
	}
 
	@Override
	public int delStu(int sid) {
		int n = 0;
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "delete from tb_stu where sid=?";
			//获得执行对象
			ps=con.prepareStatement(sql);
			//给占位符赋值
			ps.setInt(1, sid);
			//给n赋值
			n=ps.executeUpdate();
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			DBHelper.close(con, ps, rs);
		}
		return n;
	}
 
	@Override
	public int upStu(Student stu, int sid) {
		int  n = 0;
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "update tb_stu set sname=?,cid=?,hid=?,tid=? where sid=?";
			//获得执行对象
			ps=con.prepareStatement(sql);
			//给占位符赋值
			ps.setString(1, stu.getSname());
			ps.setInt(2, stu.getC().getCid());
			ps.setString(3, stu.getSs());
			ps.setInt(4, stu.getTea().getTid());
			ps.setInt(5, sid);
			//给n赋值
			n=ps.executeUpdate();
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			DBHelper.close(con, ps, rs);
		}
		return n;
	}
	
	
 
	@Override
	public int getRows(String str) {
		int n = 0;
		try {
			con = DBHelper.getConnection();
			String sql = "select count(*) from ?";
			ps=con.prepareStatement(sql);
			ps.setString(1, str);
			rs=ps.executeQuery();
			if(rs.next()) {
				n=rs.getInt(1);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			DBHelper.close(con, ps, null);
		}
		return n;
	}
	
	public static void main(String[] args) {
		StuDao stu = new StuDao();
//		System.out.println(123);
		/*List sd = stu.getAll();
		for (Student student : sd) {
			System.out.println(student);
		}*/
		/*Student stu2 = stu.getStu(3);
		System.out.println(stu2);*/
		/*List mh = stu.getMH("sname", "三", 2, 2);
		for (Student student : mh) {
			System.out.println(student+"=====================");
		}*/
		List mh = stu.getMH("278", "1", "2202", 1, 2);
		for (Student student : mh) {
			System.out.println(student+"=================");
		}
		
	}
	
}

教师

package com.hemingxiang.dao;

import java.util.List;
 
import com.hemingxiang.entity.Teacher;
 /**
 * 数据访问层接口类
 * @author hmx
 *
 */
public interface ITeacDao {
	/**
	 * 查询单个教员
	 * @param tid 教员编号
	 * @return 教员对象
	 */
	public Teacher getTea(int tid);
	
	/**
	 * 查询所有教员
	 * @return
	 */
	public List getAll();
}

package com.hemingxiang.dao;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
 
import com.hemingxiang.entity.Teacher;
import com.hemingxiang.utils.DBHelper;
 
/**
 * 数据库访问层
 * @author hmx
 *
 */
public class TeaDao implements ITeacDao{
	
	//三兄弟
	Connection con = null;
	PreparedStatement ps =null;
	ResultSet rs = null;
 
	@Override
	public Teacher getTea(int tid) {
		Teacher tea = new Teacher();
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "select * from tb_teacher where tid=?";
			//获得执行对象
			ps=con.prepareStatement(sql);
			//给占位符赋值
			ps.setInt(1, tid);
			//给rs赋值
			rs=ps.executeQuery();
			//判断
			if(rs.next()) {
				tea.setTid(rs.getInt(1));
				tea.setTname(rs.getString(2));
				tea.setC(new ClassDao().getClz(3));
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		finally {
			DBHelper.close(con, ps, rs);
		}
		return tea;
	}
 
	@Override
	public List getAll() {
		List list = new ArrayList();
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "select * from tb_teacher";
			//获得执行对象
			ps=con.prepareStatement(sql);
			//给rs赋值
			rs=ps.executeQuery();
			//判断
			while(rs.next()) {
				Teacher tea = new Teacher();
				tea.setTid(rs.getInt(1));
				tea.setTname(rs.getString(2));
				tea.setC(new ClassDao().getClz(rs.getInt(3)));
				//加进去
				list.add(tea);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		finally {
			DBHelper.close(con, ps, rs);
		}
		return list;
	}
	
}

爱好

package com.hemingxiang.dao;
/**
 * 数据库访问层接口类
 * @author hmx
 *
 */
 
import java.util.List;
 
import com.hemingxiang.entity.Habby;
 
public interface IHobbyDao {
	/**
	 * 查询单个
	 * @param hid 爱好编号
	 * @return 爱好的对象
	 */
	public Habby getHob(int hid);
	
	/**
	 * 查询所有
	 * @return 爱好的集合
	 */
	public List getAll();
}

package com.hemingxing.dao;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
 
import com.hemingxing.entity.Habby;
import com.hemingxing.util.DBHelper;
 
/**
 * 数据库访问层
 * @author hmx
 *
 */
public class HobbyDao implements IHobbyDao{
 
	//三兄弟
	Connection con = null;
	PreparedStatement ps =null;
	ResultSet rs = null;
		
	
	@Override
	public Habby getHob(int hid) {
		Habby h = new Habby();
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "select * from tb_habby where hid=?";
			//获得执行对象
			ps=con.prepareStatement(sql);
			//给占位符赋值
			ps.setInt(1, hid);
			//给rs赋值
			rs=ps.executeQuery();
			//判断
			if(rs.next()) {
				h.setHid(rs.getString(1));
				h.setHname(rs.getString(2));
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		finally {
			DBHelper.close(con, ps, rs);
		}
		return h;
	}
 
 
	@Override
	public List getAll() {
		List list = new ArrayList();
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "select * from tb_habby";
			//获得执行对象
			ps=con.prepareStatement(sql);
			//给rs赋值
			rs=ps.executeQuery();
			//遍历
			while(rs.next()) {
				Habby h = new Habby();
				h.setHid(rs.getString(1));
				h.setHname(rs.getString(2));
				//加进去
				list.add(h);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			DBHelper.close(con, ps, rs);
		}
		return list;
	}
	
}

班级

package com.hemingxiang.dao;
/**
 * 数据库访问层
 * @author hmx
 *
 */
 
import java.util.List;
 
import com.hemingxiang.entity.Class;
 
public interface IClassDao {
	/**
	 * 查询单个班级
	 * @return 班级对象
	 */
	public Class  getClz(int cid);
	
	/**
	 * 查询所有
	 * @return 班级和集合
	 */
	public List getAll();
}

package com.hemingxiang.dao;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
 
import com.hemingxiang.entity.Class;
import com.hemingxiang.util.DBHelper;
 
/**
 * 数据库访问层
 * @author hmx
 *
 */
public class ClassDao implements IClassDao{
 
	//三兄弟
	Connection con = null;
	PreparedStatement ps =null;
	ResultSet rs = null;
	
	@Override
	public Class getClz(int cid) {
		Class clz = new Class();
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "select * from tb_class where cid=?";
			//获得执行对象
			ps=con.prepareStatement(sql);
			//给占位符赋值
			ps.setInt(1, cid);
			//给rs赋值
			rs=ps.executeQuery();
			//判断
			if(rs.next()) {
				clz.setCid(rs.getInt(1));
				clz.setCname(rs.getString(2));
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			DBHelper.close(con, ps, rs);
		}
		return clz;
	}
 
	@Override
	public List getAll() {
		List list = new ArrayList();
		try {
			//获得连接
			con = DBHelper.getConnection();
			//定义sql语句
			String sql = "select * from tb_class";
			//获得执行对象
			ps=con.prepareStatement(sql);
			//给rs赋值
			rs=ps.executeQuery();
			//遍历
			while(rs.next()) {
				Class c = new Class();
				c.setCid(rs.getInt(1));
				c.setCname(rs.getString(2));
				//加进去
				list.add(c);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			DBHelper.close(con, ps, rs);
		}
		return list;
	}
	
}

com.hemingxiang.biz (业务逻辑层)

学生

package com.hemingxiang.biz;
 
import java.util.List;
 
import com.hemingxiang.entity.Student;
 
/**
 * 业务逻辑层设计类
 * @author hmx
 *
 */
public interface IStuBiz {
	
	/**
	 * 查询单个
	 * @param sid 学生编号
	 * @return 学生对象
	 */
	public Student getStu(int sid) ;
	
	
	/**
	 * 查询所有
	 * @return 查询的结果集合
	 */
	public List getAll();
	
	/**
	 * 模糊查询
	 * @param colName 要查询的列名
	 * @param str 关键字
	 * @return 对象
	 */
	public List getMH(String ctr,String htr, String str,int pageIndex,int pageSize);
	/**
	 * 增加学生
	 * @param stu 学生对象
	 * @return 影响行数
	 */
	public int addStu(Student stu);
	
	/**
	 * 删除学生
	 * @param sid 学生编号
	 * @return 影响行数
	 */
	public int delStu(int sid);
	
	/**
	 * 修改学生 
	 * @param stu 要修改的对象
	 * @param sid 学生编号
	 * @return 影响行数
	 */
	public int upStu(Student stu,int sid);
	
	/**
	 * 总行数
	 * @return
	 */
	public int getRows(String str);
}

package com.hemingxiang.biz;
/**
 * 业务逻辑层
 * @author hmx
 *
 */
 
import java.util.List;
 
import com.hemingxiang.dao.IStuDao;
import com.hemingxiang.dao.StuDao;
import com.hemingxiang.entity.Student;
 
public class StuBiz implements IStuBiz{
	//调用数据库访问层
	IStuDao isd = new StuDao();
 
	@Override
	public List getAll() {
		// TODO Auto-generated method stub
		return isd.getAll();
	}
 
	@Override
	public int addStu(Student stu) {
		// TODO Auto-generated method stub
		return isd.addStu(stu);
	}
 
	@Override
	public int delStu(int sid) {
		// TODO Auto-generated method stub
		return isd.delStu(sid);
	}
 
	@Override
	public int upStu(Student stu, int sid) {
		// TODO Auto-generated method stub
		return isd.upStu(stu, sid);
	}
 
	@Override
	public Student getStu(int sid) {
		// TODO Auto-generated method stub
		return isd.getStu(sid);
	}
 
	@Override
	public List getMH(String ctr, String htr, String str, int pageIndex, int pageSize) {
		// TODO Auto-generated method stub
		return isd.getMH(ctr, htr, str, pageIndex, pageSize);
	}
 
	@Override
	public int getRows(String str) {
		// TODO Auto-generated method stub
		return isd.getRows(str);
	}
	
}

教师

package com.hemingxiang.biz;
/**
 * 业务逻辑层接口类
 * @author hmx
 *
 */
 
import java.util.List;
 
import com.hemingxiang.entity.Teacher;
 
public interface ITeacBiz {
	/**
	 * 查询单个教员
	 * @param tid 教员编号
	 * @return 教员对象
	 */
	public Teacher getTea(int tid);
	
	/**
	 * 查询所有教员
	 * @return
	 */
	public List getAll();
	
}

package com.hemingxiang.biz;
/**
 * 业务逻辑层
 * @author hmx
 *
 */
 
import java.util.List;
 
import com.hemingxiang.dao.ITeacDao;
import com.hemingxiang.dao.TeaDao;
import com.hemingxiang.entity.Teacher;
 
public class TeaBiz implements ITeacBiz{
	//调用数据库访问层
	ITeacDao itd = new TeaDao();
 
	@Override
	public Teacher getTea(int tid) {
		// TODO Auto-generated method stub
		return itd.getTea(tid);
	}
 
	@Override
	public List getAll() {
		// TODO Auto-generated method stub
		return itd.getAll();
	}
	
	
}

爱好

package com.hemingxiang.biz;
/**
 * 业务逻辑层接口类
 * @author hmx
 *
 */
 
import java.util.List;
 
import com.hemingxiang.entity.Habby;
 
public interface IHobbyBiz {
	/**
	 * 查询单个
	 * @param hid 爱好编号
	 * @return 爱好的对象
	 */
	public Habby getHob(int hid);
	
	/**
	 * 查询所有
	 * @return 爱好的集合
	 */
	public List getAll();
}

班级

package com.hemingxiang.biz;
 
import java.util.List;
 
import com.hemingxiang.entity.Class;
/**
 * 业务逻辑层接口类
 * @author hmx
 *
 */
public interface IClassBiz {
	/**
	 * 查询单个班级
	 * @return 班级对象
	 */
	public Class  getClz(int cid);
	
	/**
	 * 查询所有
	 * @return 班级和集合
	 */
	public List getAll();
}

package com.hemingxiang.biz;
/***
 * 业务逻辑层
 * @author hmx
 *
 */
 
import java.util.List;
 
import com.hemingxiang.dao.ClassDao;
import com.hemingxiang.dao.IClassDao;
import com.hemingxiang.entity.Class;
 
public class ClassBiz implements IClassBiz{
	//调用数据库访问层
	IClassDao icd = new ClassDao();
 
	@Override
	public Class getClz(int cid) {
		// TODO Auto-generated method stub
		return icd.getClz(cid);
	}
 
	@Override
	public List getAll() {
		// TODO Auto-generated method stub
		return icd.getAll();
	}
	
}

com.hemingxiang.servlet

界面绑值&模糊查询

package com.hemingxiang.servlet;
 
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.hemingxiang.biz.ClassBiz;
import com.hemingxiang.biz.HobbyBiz;
import com.hemingxiang.biz.IClassBiz;
import com.hemingxiang.biz.IHobbyBiz;
import com.hemingxiang.biz.IStuBiz;
import com.hemingxiang.biz.ITeacBiz;
import com.hemingxiang.biz.StuBiz;
import com.hemingxiang.biz.TeaBiz;
import com.hemingxiang.entity.Class;
import com.hemingxiang.entity.Habby;
import com.hemingxiang.entity.Student;
import com.hemingxiang.entity.Teacher;
 
/**
 * 主界面绑值以及模糊查询
 */
@WebServlet("/index.do")
public class IndexServlet extends HttpServlet {
	
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doPost(request, response);
	}
 
	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//设置编码方式
		request.setCharacterEncoding("utf-8");
		response.setCharacterEncoding("utf-8");
		response.setContentType("text/html; charset=UTF-8");
		
		//获取out
		PrintWriter out = response.getWriter();
		
		//调用biz层
		IStuBiz stb = new StuBiz();
		ITeacBiz itb = new TeaBiz();
		IClassBiz icb = new ClassBiz();
		IHobbyBiz ihb = new HobbyBiz();
		
		//定义页码页数
		int pageIndex=1;
		int pageSize=2;
		//接收表单值
		String cid = request.getParameter("ctr");//班级
		String hid = request.getParameter("htr");//爱好
		String tid = request.getParameter("str");//教员
		
		if(tid==null) {
			tid="";
		}
		if(hid==null) {
			hid="";
		}
		if(cid==null) {
			cid="";
		}
		
		String pid = request.getParameter("pid");
		if(pid!=null) {
			pageIndex=Integer.parseInt(pid);
		}
		
		//select * from tb_teacher where tid like '%"+hid+"%'
		int rows = stb.getRows("  tb_stu where hid like '%"+hid+"%' and tid like '%"+tid+"%' and cid like '%"+cid+"%' ");
		int max = rows/pageSize;
		if(rows%pageSize!=0) {
			max++;
		}
		if(max==0) {
			max=1;
		}
		
		//调用方法
		List mytea = itb.getAll();
		List myclz = icb.getAll();
		List myh = ihb.getAll();
		List myls = stb.getMH(cid, hid, tid, pageIndex,pageSize);
//		Student stu = new Student();
//		List ls = stu.getLs();
//		String aa = "";
//		for (Habby habby : ls) {
//			aa+=habby+",";
//		}
		
		/*int rows = */
		request.setAttribute("mytea", mytea);
		request.setAttribute("myclz", myclz);
		request.setAttribute("myh", myh);
		request.setAttribute("max", max);
		request.setAttribute("pageIndex", pageIndex);
		request.setAttribute("myls", myls);
		//判断
		request.getRequestDispatcher("index.jsp").forward(request, response);
		/*if(myls!=null) {
			
			
		}
		else {
			System.out.println("检查dao方法");
		}*/
		
	}
 
}

增加

package com.hemingxiang.servlet;
 
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.hemingxiang.biz.ClassBiz;
import com.hemingxiang.biz.HobbyBiz;
import com.hemingxiang.biz.IClassBiz;
import com.hemingxiang.biz.IHobbyBiz;
import com.hemingxiang.biz.IStuBiz;
import com.hemingxiang.biz.ITeacBiz;
import com.hemingxiang.biz.StuBiz;
import com.hemingxiang.biz.TeaBiz;
import com.hemingxiang.entity.Class;
import com.hemingxiang.entity.Habby;
import com.hemingxiang.entity.Student;
import com.hemingxiang.entity.Teacher;
 
/**
 * 增加前增加界面的绑值
 */
@WebServlet("/add1.do")
public class AddIndexServlet extends HttpServlet {
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doPost(request, response);
	}
 
	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//设置编码方式
		request.setCharacterEncoding("utf-8");
		response.setCharacterEncoding("utf-8");
		response.setContentType("text/html; charset=UTF-8");
		
		//获取out
		PrintWriter out = response.getWriter();
		
		
		//调用biz层
		IStuBiz stb = new StuBiz();
		ITeacBiz itb = new TeaBiz();
		IClassBiz icb = new ClassBiz();
		IHobbyBiz ihb = new HobbyBiz();
		//调用方法
		List myls = stb.getAll();
		List mytea = itb.getAll();
		List myclz = icb.getAll();
		List myh = ihb.getAll();
		
		request.setAttribute("mytea", mytea);
		request.setAttribute("myclz", myclz);
		request.setAttribute("myh", myh);
		//判断
		if(myls!=null) {
			request.setAttribute("myls", myls);
			request.getRequestDispatcher("add.jsp").forward(request, response);
		}
		else {
			System.out.println("检查dao方法");
		}
		
	}
 
}

package com.hemingxiang.servlet;
 
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.hemingxiang.biz.ClassBiz;
import com.hemingxiang.biz.HobbyBiz;
import com.hemingxiang.biz.IClassBiz;
import com.hemingxiang.biz.IHobbyBiz;
import com.hemingxiang.biz.IStuBiz;
import com.hemingxiang.biz.ITeacBiz;
import com.hemingxiang.biz.StuBiz;
import com.hemingxiang.biz.TeaBiz;
import com.hemingxiang.entity.Class;
import com.hemingxiang.entity.Habby;
import com.hemingxiang.entity.Student;
import com.hemingxiang.entity.Teacher;
 
/**
 * 执行增加
 */
@WebServlet("/add.do")
public class AddServlet extends HttpServlet {
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doPost(request, response);
	}
 
	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//设置编码方式
		request.setCharacterEncoding("utf-8");
		response.setCharacterEncoding("utf-8");
		response.setContentType("text/html; charset=UTF-8");
		
		//获取out
		PrintWriter out = response.getWriter();
		
		//接收值
		String sid = request.getParameter("sid");
		String sname = request.getParameter("sname");
		//System.out.println(sid+sname+"======================");
		String tid = request.getParameter("tname");
		String cid = request.getParameter("cname");
		
		String [] id = request.getParameterValues("hname");
		String hb = "";
		for (String string : id) {
			hb+=string;
		}
		//System.out.println(hb+"=============="+id);
		//调用biz层
		ITeacBiz itb = new TeaBiz();
		Teacher tea = itb.getTea(Integer.valueOf(tid));
		
		IClassBiz icb = new ClassBiz();
		Class clz = icb.getClz(Integer.valueOf(cid));
		
		IStuBiz stb = new StuBiz();
		Student stu = new Student(Integer.parseInt(sid), sname, clz, tea,hb);
		int n = stb.addStu(stu);
		
		
		//判断
		if(n>0) {
			out.print("");
		}
		else {
			System.out.println("检查dao方法");
		}
		
	}
 
}

修改

package com.hemingxiang.servlet;
 
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.hemingxiang.biz.ClassBiz;
import com.hemingxiang.biz.HobbyBiz;
import com.hemingxiang.biz.IClassBiz;
import com.hemingxiang.biz.IHobbyBiz;
import com.hemingxiang.biz.IStuBiz;
import com.hemingxiang.biz.ITeacBiz;
import com.hemingxiang.biz.StuBiz;
import com.hemingxiang.biz.TeaBiz;
import com.hemingxiang.entity.Class;
import com.hemingxiang.entity.Habby;
import com.hemingxiang.entity.Student;
import com.hemingxiang.entity.Teacher;
 
/**
 * 修改前的修改界面的绑值
 */
@WebServlet("/preupdate.do")
public class PreUpdateServlet extends HttpServlet {
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doPost(request, response);
	}
 
	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//设置编码方式
		request.setCharacterEncoding("utf-8");
		response.setCharacterEncoding("utf-8");
		response.setContentType("text/html; charset=UTF-8");
		
		//获取out
		PrintWriter out = response.getWriter();
		
		//接收值
		String sid = request.getParameter("sid");
		
		//调用biz层
		IStuBiz stb = new StuBiz();
		Student stu = stb.getStu(Integer.parseInt(sid));
		
		
		IHobbyBiz ihb = new HobbyBiz();
		
		IClassBiz icb = new ClassBiz();
		List clzall = icb.getAll();
		
		ITeacBiz itb = new TeaBiz();
		List teaall = itb.getAll();
		
		List hall = ihb.getAll();
		
		
		//实例化一个爱好的集合
		List ls = new ArrayList();
		String ss = stu.getSs();
		String[] split = ss.split(",");
		for (String string : split) {
			Habby hob = ihb.getHob(Integer.parseInt(string));
			//加进去
			ls.add(hob);
		}
		
		//将集合存起来
		request.setAttribute("clzall", clzall);
		request.setAttribute("teaall", teaall);
		request.setAttribute("ls", ls);
		request.setAttribute("hall", hall);
		request.setAttribute("stu", stu);
		
		//+clzall+teaall+ls+hall
		//System.out.println(stu+"=================");
		
		//转发
		request.getRequestDispatcher("update.jsp").forward(request, response);
		
		
	}
}

package com.hemingxiang.servlet;
 
import java.io.IOException;
import java.io.PrintWriter;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.hemingxiang.biz.ClassBiz;
import com.hemingxiang.biz.IClassBiz;
import com.hemingxiang.biz.IStuBiz;
import com.hemingxiang.biz.ITeacBiz;
import com.hemingxiang.biz.StuBiz;
import com.hemingxiang.biz.TeaBiz;
import com.hemingxiang.entity.Class;
import com.hemingxiang.entity.Student;
import com.hemingxiang.entity.Teacher;
 
/**
 * 执行修改操作
 */
@WebServlet("/update.do")
public class UpdateServlet extends HttpServlet {
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doPost(request, response);
	}
 
	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//设置编码方式
		request.setCharacterEncoding("utf-8");
		response.setCharacterEncoding("utf-8");
		response.setContentType("text/html; charset=UTF-8");
		
		//获取out
		PrintWriter out = response.getWriter();
		
		//接收值
		String sid = request.getParameter("sid");
		String sname = request.getParameter("sname");
		String tid = request.getParameter("tname");
		String cid = request.getParameter("cname");
		
		String [] id = request.getParameterValues("hname");
		String hb = "";
		for (String string : id) {
			hb+=string;
		}
		
		//调用biz层
		ITeacBiz itb = new TeaBiz();
		Teacher tea = itb.getTea(Integer.valueOf(tid));
		
		IClassBiz icb = new ClassBiz();
		Class clz = icb.getClz(Integer.valueOf(cid));
		
		IStuBiz stb = new StuBiz();
		Student stu = new Student(Integer.parseInt(sid), sname, clz, tea, hb);
		int n = stb.upStu(stu, Integer.parseInt(sid));
		
		
		//判断
		if(n>0) {
			out.print("");
		}
		else {
			System.out.println("检查dao方法");
		}
		
	}
 
 
}

删除

package com.hemingxiang.servlet;
 
import java.io.IOException;
import java.io.PrintWriter;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.hemingxiang.biz.ClassBiz;
import com.hemingxiang.biz.IClassBiz;
import com.hemingxiang.biz.IStuBiz;
import com.hemingxiang.biz.ITeacBiz;
import com.hemingxiang.biz.StuBiz;
import com.hemingxiang.biz.TeaBiz;
import com.hemingxiang.entity.Class;
import com.hemingxiang.entity.Student;
import com.hemingxiang.entity.Teacher;
 
/**
 * 执行删除
 */
@WebServlet("/delete.do")
public class DeleteServlet extends HttpServlet {
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doPost(request, response);
	}
 
	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//设置编码方式
		request.setCharacterEncoding("utf-8");
		response.setCharacterEncoding("utf-8");
		response.setContentType("text/html; charset=UTF-8");
		
		//获取out
		PrintWriter out = response.getWriter();
		
		//接收值
		String sid = request.getParameter("sid");
		//System.out.println(sid+"===================");
		
		//调用biz层
		IStuBiz stb = new StuBiz();
		int n = stb.delStu(Integer.parseInt(sid));
		
		
		//判断
		if(n>0) {
			out.print("");
		}
		else {
			System.out.println("检查dao方法");
		}
		
	}
 
}

四、界面

index.jsp主界面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core"  prefix="c"%>




Insert title here



主界面
	
		
		
		
		
		
		
			
				
			
			爱好：
			
				${hobby.hname}
			
			
		

	
 
 
 
	
		
			
		
	
		
				
			
				学生的id
				学生的姓名
				学生的教员
				学生的所在班级
				学生的爱好
				操作
			
			
				
				
					${stu.sid}
					${stu.sname}
					${stu.tea.tname}
					${stu.c.cname}
					
						
							${h.hname}
						
					
					
						修改
						删除
					
					
				
		
		首页
		上一页
		[${pageIndex}/${max}]
		下一页
		尾页

界面

删除功能

add.jsp增加

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
     
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core"  prefix="c"%>




Insert title here



新增页面
			                                        
	
	
		
			学号
			
		
		
		
			名字
			
		
		
		
			教员
			
				
			
		
		
		
		
			班级
			
				
			
		
		
		
		
			爱好
			
				
					
				
				
					${hobby.hname}

界面

update.jsp修改

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core"  prefix="c"%>




Insert title here



修改页面
			                                        
	
	
		
		
			学号
			
		
		
		
			名字
			
		
		
		
			教员
			
				
			
		
		
		
		
			班级
			
				
			
		
		
		
		
			爱好
			
				
					checked="checked"/>${hobby.hname}

界面

你可能感兴趣的:(java,开发语言)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式 java
文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
ios内付费 374016526 ios 内付费
近年来写了很多IOS的程序，内付费也用到不少，使用IOS的内付费实现起来比较麻烦，这里我写了一个简单的内付费包，希望对大家有帮助。具体使用如下: 这里的sender其实就是调用者，这里主要是为了回调使用。 [KuroStoreApi kuroStoreProductId:@"产品ID" storeSender:self storeFinishCallBa
20 款优秀的 Linux 终端仿真器 brotherlamp linux linux视频 linux资料 linux自学 linux教程
终端仿真器是一款用其它显示架构重现可视终端的计算机程序。换句话说就是终端仿真器能使哑终端看似像一台连接上了服务器的客户机。终端仿真器允许最终用户用文本用户界面和命令行来访问控制台和应用程序。（LCTT 译注：终端仿真器原意指对大型机-哑终端方式的模拟，不过在当今的 Linux 环境中，常指通过远程或本地方式连接的伪终端，俗称“终端”。）你能从开源世界中找到大量的终端仿真器，它们
Solr Deep Paging(solr 深分页) eksliang solr深分页 solr分页性能问题
转载请出自出处：http://eksliang.iteye.com/blog/2148370 作者：eksliang(ickes) blg:http://eksliang.iteye.com/ 概述长期以来，我们一直有一个深分页问题。如果直接跳到很靠后的页数，查询速度会比较慢。这是因为Solr的需要为查询从开始遍历所有数据。直到Solr的4.7这个问题一直没有一个很好的解决方案。直到solr
数据库面试题 18289753290 面试题数据库
1.union ,union all 网络搜索出的最佳答案： union和union all的区别是,union会自动压缩多个结果集合中的重复结果，而union all则将所有的结果全部显示出来，不管是不是重复。 Union：对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序； Union All：对两个结果集进行并集操作，包括重复行，不进行排序； 2.索引有哪些分类？作用是
Android TV屏幕适配酷的飞上天空 android
先说下现在市面上TV分辨率的大概情况两种分辨率为主 1.720标清，分辨率为1280x720. 屏幕尺寸以32寸为主，部分电视为42寸 2.1080p全高清，分辨率为1920x1080 屏幕尺寸以42寸为主，此分辨率电视屏幕从32寸到50寸都有适配遇到问题，已1080p尺寸为例：分辨率固定不变，屏幕尺寸变化较大。如：效果图尺寸为1920x1080，如果使用d
Timer定时器与ActionListener联合应用永夜-极光 java
功能:在控制台每秒输出一次代码: package Main; import javax.swing.Timer; import java.awt.event.*; public class T { private static int count = 0; public static void main(String[] args){
Ubuntu14.04系统Tab键不能自动补全问题解决随便小屋 Ubuntu 14.04
Unbuntu 14.4安装之后就在终端中使用Tab键不能自动补全，解决办法如下： 1、利用vi编辑器打开/etc/bash.bashrc文件（需要root权限） sudo vi /etc/bash.bashrc 接下来会提示输入密码 2、找到文件中的下列代码 #enable bash completion in interactive shells #if
学会人际关系三招轻松走职场 aijuans 职场
要想成功，仅有专业能力是不够的，处理好与老板、同事及下属的人际关系也是门大学问。如何才能在职场如鱼得水、游刃有余呢？在此，教您简单实用的三个窍门。　　第一，多汇报最近，管理学又提出了一个新名词“追随力”。它告诉我们，做下属最关键的就是要多请示汇报，让上司随时了解你的工作进度，有了新想法也要及时建议。不知不觉，你就有了“追随力”，上司会越来越了解和信任你。　　第二，勤沟通团队的力
《O2O：移动互联网时代的商业革命》读书笔记 aoyouzi 读书笔记
移动互联网的未来：碎片化内容+碎片化渠道=各式精准、互动的新型社会化营销。 O2O：Online to OffLine 线上线下活动 O2O就是在移动互联网时代，生活消费领域通过线上和线下互动的一种新型商业模式。手机二维码本质：O2O商务行为从线下现实世界到线上虚拟世界的入口。线上虚拟世界创造的本意是打破信息鸿沟，让不同地域、不同需求的人
js实现图片随鼠标滚动的效果百合不是茶 JavaScript 滚动属性的获取图片滚动属性获取页面加载
1,获取样式属性值 top 与顶部的距离 left 与左边的距离 right 与右边的距离 bottom 与下边的距离 zIndex 层叠层次例子:获取左边的宽度,当css写在body标签中时 <div id="adver" style="position:absolute;top:50px;left:1000p
ajax同步异步参数async bijian1013 jquery Ajax async
开发项目开发过程中，需要将ajax的返回值赋到全局变量中，然后在该页面其他地方引用，因为ajax异步的原因一直无法成功，需将async:false，使其变成同步的。格式： $.ajax({ type: 'POST', ur
Webx3框架（1） Bill_chen eclipse spring maven 框架 ibatis
Webx是淘宝开发的一套Web开发框架，Webx3是其第三个升级版本；采用Eclipse的开发环境，现在支持java开发；采用turbine原型的MVC框架，扩展了Spring容器，利用Maven进行项目的构建管理，灵活的ibatis持久层支持，总的来说，还是一套很不错的Web框架。 Webx3遵循turbine风格，velocity的模板被分为layout/screen/control三部
【MongoDB学习笔记五】MongoDB概述 bit1129 mongodb
MongoDB是面向文档的NoSQL数据库，尽量业界还对MongoDB存在一些质疑的声音，比如性能尤其是查询性能、数据一致性的支持没有想象的那么好，但是MongoDB用户群确实已经够多。MongoDB的亮点不在于它的性能，而是它处理非结构化数据的能力以及内置对分布式的支持(复制、分片达到的高可用、高可伸缩)，同时它提供的近似于SQL的查询能力，也是在做NoSQL技术选型时，考虑的一个重要因素。Mo
spring/hibernate/struts2常见异常总结白糖_ Hibernate
Spring ①ClassNotFoundException: org.aspectj.weaver.reflect.ReflectionWorld$ReflectionWorldException 缺少aspectjweaver.jar，该jar包常用于spring aop中 ②java.lang.ClassNotFoundException: org.sprin
jquery easyui表单重置(reset)扩展思路 bozch form jquery easyui reset
在jquery easyui表单中尚未提供表单重置的功能，这就需要自己对其进行扩展。扩展的时候要考虑的控件有： combo,combobox,combogrid,combotree,datebox,datetimebox 需要对其添加reset方法，reset方法就是把初始化的值赋值给当前的组件，这就需要在组件的初始化时将值保存下来。在所有的reset方法添加完毕之后，就需要对fo
编程之美-烙饼排序 bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; /* *《编程之美》的思路是：搜索+剪枝。有点像是写下棋程序：当前情况下，把所有可能的下一步都做一遍；在这每一遍操作里面，计算出如果按这一步走的话，能不能赢（得出最优结果）。 *《编程之美》上代码有很多错误，且每个变量的含义令人费解。因此我按我的理解写了以下代码： */
Struts1.X 源码分析之ActionForm赋值原理 chenbowen00 struts
struts1在处理请求参数之前，首先会根据配置文件action节点的name属性创建对应的ActionForm。如果配置了name属性，却找不到对应的ActionForm类也不会报错，只是不会处理本次请求的请求参数。如果找到了对应的ActionForm类，则先判断是否已经存在ActionForm的实例，如果不存在则创建实例，并将其存放在对应的作用域中。作用域由配置文件action节点的s
[空天防御与经济]在获得充足的外部资源之前,太空投资需有限度 comsci 资源
这里有一个常识性的问题: 地球的资源,人类的资金是有限的,而太空是无限的..... 就算全人类联合起来,要在太空中修建大型空间站,也不一定能够成功,因为资源和资金,技术有客观的限制.... &
ORACLE临时表—ON COMMIT PRESERVE ROWS daizj oracle 临时表
ORACLE临时表转临时表：像普通表一样，有结构，但是对数据的管理上不一样，临时表存储事务或会话的中间结果集，临时表中保存的数据只对当前会话可见，所有会话都看不到其他会话的数据，即使其他会话提交了，也看不到。临时表不存在并发行为，因为他们对于当前会话都是独立的。创建临时表时，ORACLE只创建了表的结构（在数据字典中定义），并没有初始化内存空间，当某一会话使用临时表时，ORALCE会
基于Nginx XSendfile+SpringMVC进行文件下载 denger 应用服务器 Web nginx 网络应用 lighttpd
在平常我们实现文件下载通常是通过普通 read-write方式，如下代码所示。 @RequestMapping("/courseware/{id}") public void download(@PathVariable("id") String courseID, HttpServletResp
scanf接受char类型的字符 dcj3sjt126com c
/* 2013年3月11日22:35:54 目的：学习char只接受一个字符 */ # include <stdio.h> int main(void) { int i; char ch; scanf("%d", &i); printf("i = %d\n", i); scanf("%
学编程的价值 dcj3sjt126com 编程
发一个人会编程, 想想以后可以教儿女, 是多么美好的事啊, 不管儿女将来从事什么样的职业, 教一教, 对他思维的开拓大有帮助像这位朋友学习: http://blog.sina.com.cn/s/articlelist_2584320772_0_1.html VirtualGS教程 (By @林泰前): 几十年的老程序员，资深的
二维数组（矩阵）对角线输出飞天奔月二维数组
今天在BBS里面看到这样的面试题目, 1，二维数组（N*N），沿对角线方向，从右上角打印到左下角如N=4： 4*4二维数组 { 1 2 3 4 } { 5 6 7 8 } { 9 10 11 12 } {13 14 15 16 } 打印顺序 4 3 8 2 7 12 1 6 11 16 5 10 15 9 14 13 要
Ehcache（08）——可阻塞的Cache——BlockingCache 234390216 并发 ehcache BlockingCache 阻塞
可阻塞的Cache—BlockingCache 在上一节我们提到了显示使用Ehcache锁的问题，其实我们还可以隐式的来使用Ehcache的锁，那就是通过BlockingCache。BlockingCache是Ehcache的一个封装类，可以让我们对Ehcache进行并发操作。其内部的锁机制是使用的net.
mysqldiff对数据库间进行差异比较 jackyrong mysqld
mysqldiff该工具是官方mysql-utilities工具集的一个脚本，可以用来对比不同数据库之间的表结构，或者同个数据库间的表结构如果在windows下，直接下载mysql-utilities安装就可以了，然后运行后，会跑到命令行下： 1）基本用法 mysqldiff --server1=admin:12345
spring data jpa 方法中可用的关键字 lawrence.li java spring
spring data jpa 支持以方法名进行查询/删除/统计。查询的关键字为find 删除的关键字为delete/remove (>=1.7.x) 统计的关键字为count (>=1.7.x) 修改需要使用@Modifying注解 @Modifying @Query("update User u set u.firstna
Spring的ModelAndView类 nicegege spring
项目中controller的方法跳转的到ModelAndView类，一直很好奇spring怎么实现的？ /* * Copyright 2002-2010 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * yo
搭建 CentOS 6 服务器(13) - rsync、Amanda rensanning centos
（一）rsync Server端 # yum install rsync # vi /etc/xinetd.d/rsync service rsync { disable = no flags = IPv6 socket_type = stream wait
Learn Nodejs 02 toknowme nodejs
（1）npm是什么 npm is the package manager for node 官方网站：https://www.npmjs.com/ npm上有很多优秀的nodejs包，来解决常见的一些问题，比如用node-mysql，就可以方便通过nodejs链接到mysql，进行数据库的操作在开发过程往往会需要用到其他的包，使用npm就可以下载这些包来供程序调用 &nb
Spring MVC 拦截器 xp9802 spring mvc
Controller层的拦截器继承于HandlerInterceptorAdapter HandlerInterceptorAdapter.java 1 public abstract class HandlerInterceptorAdapter implements HandlerIntercep

学生的id	学生的姓名	学生的教员	学生的所在班级	学生的爱好	操作
${stu.sid}	${stu.sname}	${stu.tea.tname}	${stu.c.cname}	${h.hname}	修改删除

学号
名字
教员
班级
爱好	checked="checked"/>${hobby.hname}