数据库课程实训作业——基于SSM 框架

最新推荐文章于 2023-01-16 22:55:23 发布

丁奕斌

最新推荐文章于 2023-01-16 22:55:23 发布

阅读量761

点赞数 3

文章标签： sql java

本文链接：https://blog.csdn.net/weixin_45612340/article/details/103575938

版权

基于SSM的学生信息管理系统，大三课程实训

HAUE_CS 实训作业

HAUE_CS 实训作业

大三数据库课程实践作业，需要做一个 XX 管理系统
便想用上自己最近学习的 SSM 框架，以及一些实用的小玩意

前言

1、本人 SSM 纯属自学，且是上手做的第一个项目，本项目适合新手参考，也欢迎大佬指出问题；
2、本项目并非最终版本，很多地方有很多不足之处，可以拿来练手或者参考结构；
3、第一次写博客，编辑器用法不够熟练，看官酌情观看

使用到的软件及版本信息

eclipse IDE 2019-06
mysql 5.7
spring 5.0
mybatis
echarts 3
tomcat 9
JavaSE-1.8
没用 Maven ，所以相关 jar 包需要自行导入

整体结构

1 、有几分冗余的项目结构
在这里插入图片描述
2 、尚待完善的数据库结构
数据库用的是课本《数据库系统概论》第五版上最为著名的 Student,Course,Sc 三张表的学生信息管理
自己又加入了 user 表进行登录的验证
整体结构如下：

3、丑陋的界面

配置文件

1、web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
  <display-name>ControllerTest</display-name>

	<!-- 配置 spring 核心监听器，默认会以 /WEB-INF/applicationContext.xml 作为配置文件 -->
	<listener>
			<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	<!-- contextConfigLocation参数用来指定Spring的配置文件 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/applicationContext*.xml</param-value>
	</context-param>

	<!-- 定义Spring MVC的前端控制器 -->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>
        org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/springmvc-config.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  
  <!-- 让Spring MVC的前端控制器拦截所有请求 -->
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  
  <!-- 编码过滤器 -->
  <filter>
		<filter-name>characterEncodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
 </filter>
	<filter-mapping>
		<filter-name>characterEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
</web-app>

2、spring

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:p="http://www.springframework.org/schema/p"
xmlns:mvc="http://www.springframework.org/schema/mvc" 
xmlns:context="http://www.springframework.org/schema/context" 
xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd     
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
	<!-- 自动扫描该包，spring MVC 会将包下使用了@Controller 注解的类注册为 Spring 的 controller  -->
	<context:component-scan base-package="org.student.controller" />
	
	<!-- 默认装配方案 -->
	<mvc:annotation-driven/>
	
	<!-- 静态资源处理 
	<mvc:default-servlet-handler/>	-->
	
	<!-- 配置拦截器：对某些请求进行拦截，达到需要登录才能访问某些资源的效果，而不是可以直接通过 URL 进行访问 -->
    <mvc:interceptors>
    	<mvc:interceptor>
    		<!-- 拦截所有请求 -->
    		<mvc:mapping path="/*"/>
    		<!-- 自定义判断用户权限的拦截类 -->  
    	 	<bean class="org.student.interceptor.studentInterceptor"/>
    	</mvc:interceptor>
    </mvc:interceptors>
    
	<!-- 视图解析器  p:prefix 属性表示前缀		p:suffix 属性表示后缀-->
	<bean id="viewResolver" 
		class="org.springframework.web.servlet.view.InternalResourceViewResolver" 
			p:prefix="/WEB-INF/content/" p:suffix=".jsp"/>
</beans>

3 applicationContext

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
			            http://www.springframework.org/schema/beans/spring-beans.xsd
			            http://www.springframework.org/schema/context
			            http://www.springframework.org/schema/context/spring-context.xsd
			            http://www.springframework.org/schema/mvc
			            http://www.springframework.org/schema/mvc/spring-mvc.xsd
			            http://www.springframework.org/schema/tx
			            http://www.springframework.org/schema/tx/spring-tx.xsd
			            http://mybatis.org/schema/mybatis-spring 
			            http://mybatis.org/schema/mybatis-spring.xsd ">
			      
	<!-- mybatis:scan会将org.student.dao包里的所有接口当作mapper配置，之后可以自动引入mapper类-->  
    <mybatis:scan base-package="org.student.dao"/>   
       
	 <!-- 扫描org.student包下面的java文件，有Spring的相关注解的类，则把这些类注册为Spring的bean -->
    <context:component-scan base-package="org.student"/>
    
	<!-- 使用PropertyOverrideConfigurer后处理器加载数据源参数 -->
	<context:property-override location="classpath:db.properties"/>

	<!-- 配置c3p0数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"/>
	
	<!-- 配置SqlSessionFactory，org.mybatis.spring.SqlSessionFactoryBean是Mybatis社区开发用于整合Spring的bean -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
	    p:dataSource-ref="dataSource"/>
	
	<!-- JDBC事务管理器 -->
	<bean id="transactionManager" 
	class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
		 p:dataSource-ref="dataSource"/>
	
	<!-- 启用支持annotation注解方式事务管理 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
	
</beans>

4 数据库配置文件

dataSource.driverClass=com.mysql.jdbc.Driver
dataSource.jdbcUrl=jdbc:mysql://127.0.0.1:3306/Stu_Course?characterEncoding=utf8&useSSL=false
dataSource.user=root
dataSource.password=123456
dataSource.maxPoolSize=20
dataSource.maxIdleTime = 1000
dataSource.minPoolSize=6
dataSource.initialPoolSize=5

domain实体类

1、user

package org.student.domain;
/**
 * 
 * @author NAIL
 *
 */
public class User {
	private String loginname;
	private String password;

	public User(String loginname,String password) {
		this.loginname=loginname;
		this.password=password;
	}

	public String getLoginname() {
		return loginname;
	}

	public void setLoginname(String loginname) {
		this.loginname = loginname;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}	
	
}

2、

package org.student.domain;

import java.util.List;

public class Student {
	private String sno;
	private String sname;
	private String ssex;
	private Integer sage;
	private String sdept;

	// 外键的实现
	private List<Sc> scs; // 一对多

	public List<Sc> getScs() {
		return scs;
	}

	public void setScs(List<Sc> scs) {
		this.scs = scs;
	}

	public Student() {
		super();
	}

	public Student(String Sno, String Sname, String Ssex, int Sage, String Sdept) {
		this.sno = Sno;
		this.sname = Sname;
		this.ssex = Ssex;
		this.sage = Sage;
		this.sdept = Sdept;
	}

	public String getSno() {
		return sno;
	}

	public void setSno(String sno) {
		this.sno = sno;
	}

	public String getSname() {
		return sname;
	}

	public void setSname(String sname) {
		this.sname = sname;
	}

	public String getSsex() {
		return ssex;
	}

	public void setSsex(String ssex) {
		this.ssex = ssex;
	}

	public Integer getSage() {
		return sage;
	}

	public void setSage(Integer sage) {
		this.sage = sage;
	}

	public String getSdept() {
		return sdept;
	}

	public void setSdept(String sdept) {
		this.sdept = sdept;
	}

	@Override
	public String toString() {
		return "Student [sno=" + sno + ", sname=" + sname + ", ssex=" + ssex + ", sage=" + sage + ", sdept=" + sdept
				+ ", scs=" + scs + "]";
	}
	
	
	
}

3、Course

package org.student.domain;

import java.util.List;

public class Course {
	@Override
	public String toString() {
		return "Course [cno=" + cno + ", cname=" + cname + ", cpno=" + cpno + ", ccredit=" + ccredit + ", scs=" + scs
				+ "]";
	}
	private String cno;
	private String cname;
	private String cpno;
	private Integer ccredit;
	
	//外键的实现
	private List<Sc> scs;						//一对多
	
	public List<Sc> getScs() {
		return scs;
	}
	public void setScs(List<Sc> scs) {
		this.scs = scs;
	}
	public Course() {
		super();
	}
	public Course(String cno, String cname, String cpno, Integer ccredit) {
		super();
		this.cno = cno;
		this.cname = cname;
		this.cpno = cpno;
		this.ccredit = ccredit;
	}
	public String getCno() {
		return cno;
	}
	public void setCno(String cno) {
		this.cno = cno;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}
	public String getCpno() {
		return cpno;
	}
	public void setCpno(String cpno) {
		this.cpno = cpno;
	}
	public Integer getCcredit() {
		return ccredit;
	}
	public void setCcredit(Integer ccredit) {
		this.ccredit = ccredit;
	}
	public boolean getAllAttr() {
		if(this.cno != null || this.cname != null || this.cpno != null || this.ccredit != null) {
			return true;
		}
		return false;
	}
}

4、Sc

package org.student.domain;

public class Sc {
	@Override
	public String toString() {
		return "Sc [sno=" + sno + ", cno=" + cno + ", grade=" + grade + ", student=" + student + ", course=" + course
				+ "]";
	}
	private String sno;
	private String cno;
	private Integer grade;
	
	//外键的实现
	private Student student;		//一条成绩数据之多对应一个学生 --> 一对多
	private Course course;		//一们课程可以对应多条成绩数据 --> 一对多
	
	public Student getStudent() {
		return student;
	}

	public void setStudent(Student student) {
		this.student = student;
	}

	public Course getCourse() {
		return course;
	}

	public void setCourse(Course course) {
		this.course = course;
	}

	public Sc() {
		super();
	}
	
	public Sc(String sno, String cno, Integer grade) {
		super();
		this.sno = sno;
		this.cno = cno;
		this.grade = grade;
	}

	public String getSno() {
		return sno;
	}
	public void setSno(String sno) {
		this.sno = sno;
	}
	public String getCno() {
		return cno;
	}
	public void setCno(String cno) {
		this.cno = cno;
	}
	public Integer getGrade() {
		return grade;
	}
	public void setGrade(Integer grade) {
		this.grade = grade;
	}
	public boolean getAllAttr() {
		if(this.sno != null || this.cno != null || this.grade != null) {
			return true;
		}
		return false;
	}
}

Controller 层

1、loginController
登陆行为

package org.student.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class LoginController {
	@RequestMapping(value="/loginForm")
	public String login() {
		System.out.println("/loginForm 受到请求");
		// 返回 loginForm.jsp 页面
		return "loginForm";
	}
	
	@RequestMapping(value="/list")
	public String list() {
		System.out.println("/list 受到请求");
		return "list";
	}
}

2、UserController

package org.student.controller;

import javax.servlet.http.HttpSession;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.student.domain.User;
import org.student.service.StudentService;

/**
 * 处理 User 请求控制器
 * @author NAIL
 *
 */
@Controller
public class UserController {
	// 自动注入 studentService
	@Autowired
	@Qualifier("studentService")
	private StudentService studentService;
	/**
	 * 处理login 请求
	 */
	@RequestMapping("/login")
	public String login(String loginname, String password, Model model, HttpSession session) {
		User user = studentService.login(loginname, password);
		if(user != null) {
			//登陆成功，将 user 对象设置到 HttpSession 作用域
			session.setAttribute("user_session", user);
			//设置session 有效时间为 30 * 60 秒
			session.setMaxInactiveInterval(30 * 60);  
			//转发到 main 请求
			return "/list";
		}else {
			//登陆失败
			model.addAttribute("message", "登录失败");
			return "/loginForm";
		}
		
	}

}

3、StudentController

package org.student.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.student.domain.Student;
import org.student.service.StudentService;

@Controller
public class StudentColtroller {
	@Autowired
	@Qualifier("studentService")
	private StudentService studentService;
	
	/**
	 * 查询学生信息，返回学生信息的 list 集合
	 */
	@RequestMapping("/studentSelect")
	 public String studentSelect(Student student,
			 Model model) {
		try {
			System.out.println("接收到的student信息为：" + student.toString());
			List<Student> stu_list = studentService.findStudentByAllAttr(student);
			model.addAttribute("message","学生详细信息查询:<hr/>");
			model.addAttribute("message1","查询结果:");
			if( stu_list != null && stu_list.size() != 0) {
				System.out.println("查询到了相应结果"+stu_list+" | | "+stu_list.size());
				model.addAttribute("res_stu_list", stu_list);
				//如果是第一次进入这个页面，那么默认提交到 selectStudent 控制器
				model.addAttribute("post_action", "studentSelect");
				//mv.setView(new RedirectView("/StudentsMessageManageSystem/studentSelect"));
			}else {
				System.out.println("查询结果为空"+stu_list+" | | "+stu_list.size());
			}
			return "student/student";
		} catch (Exception e) {
			return "student/student";
		}
	}
	
	
	/**
	 * 插入学生信息
	 */
	@RequestMapping("/studentAdd")
	public String addStudent(Student student,Model model) {

		System.out.println("插入的学生信息：" + student.toString());
		model.addAttribute("student", student);
		model.addAttribute("post_action", "studentAdd");
		model.addAttribute("message", "添加学生数据");
		model.addAttribute("message1", "插入的学生数据为：");

		try {
			if(student.getSno()==null || student.getSno().equals("")) {//插入信息中主键不存在，即学号不存在
				model.addAttribute("add_result", "请至少输入学号信息进行添加");
				return "student/studentAdd";
			}else {//输入了学号
				if(student.getSno().length() != 9) {
					model.addAttribute("add_result", "请输入长度为[9]的学号");
					return "student/studentAdd";
				}
				if(studentService.selectStudentBySno(student.getSno()) != null) {//输入的学号已经存在学生与之对应
					model.addAttribute("add_result", "插入的学号重复");
					return "student/studentAdd";
				}else {//插入的学号不重复
					studentService.addStudent(student);
					model.addAttribute("add_success_flag", 1);
					model.addAttribute("add_result", "已成功插入该学生");
					return "success";
				}
			}
		}catch(NullPointerException nullPointerException) {
			System.out.println("第一次进入该界面，传入的学号信息为空");
			return "student/studentAdd";
		}


	}
	
	
	@RequestMapping("/studentDelete")
	public String studentDelete(String Sno, Model model) {//通过学号删除学生信息
		System.out.println("删除的学生信息为：" + studentService.selectStudentBySno(Sno).toString());
		model.addAttribute("message", "通过学号删除学生信息");			//一号 message ， 表达了返回的信息类型
		model.addAttribute("Sno", Sno);
		if(Sno != null && !Sno.equals("")) {//传入的学号不为空
			if(studentService.selectStudentBySno(Sno) != null) {//输入的学号存在对应的学生数据
				studentService.removeStudentBySno(Sno);
				model.addAttribute("add_result_info", "删除学生信息成功");					//2 表示删除学生信息成功
				model.addAttribute("delete_success_flag", 1);
				return "success";
			}else {//输入的学号不为空，但是不存在学号和输入的学号相同的学生
				model.addAttribute("add_result_info", "不存在学号为" + Sno + "的学生");
				return "student/studentDelete";
			}
		}else {//传入的学生信息为空
			model.addAttribute("add_result_info", "请输入学号！");					//1 表示传入的 Sno 为空
			return "student/studentDelete";
		}
	}
	
	@RequestMapping("/studentModify")
	public String studentModify(Student student, Model model) {
		System.out.println("修改的学生信息为：" + studentService.selectStudentBySno(student.getSno()).toString());
		model.addAttribute("message", "通过学号修改学生信息");
		String Sno = student.getSno();
		model.addAttribute("message1", "修改结果：");
		model.addAttribute("Sno", Sno);
		try {
				if(Sno == null || Sno.equals("")) {//学号为空
					model.addAttribute("modify_result", "请输入学号进行修改");
					return "student/studentModify";
				}else {//学号不为空
					if(studentService.selectStudentBySno(Sno) == null) {//不存在需要修改的学号
						model.addAttribute("modify_result", "不存在需要修改的学号所对应的学生信息");
						return "student/studentModify";
					}else {//学号不为空，且存在需要修改的学号的学生
						studentService.modifyStudent(student);
					
						model.addAttribute("modify_success_flag", 1);
						model.addAttribute("modify_result", "修改学生信息成功");
						Student modified_student = studentService.selectStudentBySno(student.getSno());
						model.addAttribute("student", modified_student);
						return "success";
					}
				}
		} catch (NullPointerException e) {
			System.out.println("第一次进入页面，学号信息为空");
			return "student/studentModify";
		}
		
	}
}

4、CourseController

package org.student.controller;


import java.util.List;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.student.domain.Course;
import org.student.domain.Sc;
import org.student.service.StudentService;

@Controller
public class CourseController {
	@Autowired
	@Qualifier("studentService")
	private StudentService studentService;
	
	/**
	 * 
	 * @param course
	 * @param model
	 * @param session
	 * @return
	 */
	@RequestMapping("/courseSelect")
	 public String courseSelect(Course course,Model model) {
		System.out.println("查询过程中的课程参数信息为" + course.toString());
		List<Course> course_list = studentService.findCourseByAllAttr(course);
		model.addAttribute("post_action", "courseSelect");
		model.addAttribute("message","课程详细信息查询:<hr/>");
		if( course_list != null && course_list.size() != 0) {
			System.out.println("查询到了相应结果"+course_list+" | | "+course_list.size());
			model.addAttribute("res_course_list", course_list);
			//如果是第一次进入这个页面，那么默认提交到 selectCourse 控制器
			model.addAttribute("message1","查询结果:");
			//mv.setView(new RedirectView("/StudentsMessageManageSystem/studentSelect"));
			
		}else {
			model.addAttribute("message", "查询结果为空");
			System.out.println("查询结果为空"+course_list+" | | "+course_list.size());
		}
		return "course/course";
	}
	
	/**
	 * 插入课程信息
	 */
	@RequestMapping("/courseAdd")
	public String addStudent(Course course,Model model) {
		System.out.println("插入过程中的课程参数信息为：" + course.toString());
		model.addAttribute("course", course);
		model.addAttribute("post_action", "courseAdd");
		model.addAttribute("message", "添加课程数据");
		model.addAttribute("message1", "插入的课程数据为：");
		System.out.println("插入过程中，course 对象的属性为：");
		try {
			if(course.getCno() == null) {//输入的课程号为空
				model.addAttribute("add_result", "请至少输入课程号以进行插入");
				return "course/courseAdd";
			}else {//输入的课程号存在
				if(studentService.selectCourseByCno(course.getCno()) != null) {//输入的课程号重复
					model.addAttribute("add_result", "输入的课程号存在重复");
					return "course/courseAdd";
				}else {//输入的课程号不重复
					//加入判断先行课是否存在
					if(course.getCpno() != null && studentService.selectCourseByCno(course.getCpno()) == null) {
						//输入了先行课，但先行课不存在
						model.addAttribute("add_result", "所插入的课程的先行课不存在");
						return "course/courseAdd";
					}else {
						studentService.addCourse(course);
						model.addAttribute("add_success_flag", 2);
						model.addAttribute("add_result", "已成功插入该课程信息");
						return "success";
					}
				}
			}
		} catch(NullPointerException nullPointerException) {
			System.out.println("第一次进入该界面，传入的课程号信息为空");
			return "course/courseAdd";
		}

		
		
	}
	
	
	@RequestMapping("/courseDelete")
	public String courseDelete(String Cno, Model model) {
		model.addAttribute("message", "通过学号删除课程信息");
		model.addAttribute("Cno", Cno);
		if(Cno != null && !Cno.equals("")) {//传入的学号不为空
			System.out.println("删除的课程信息为：" +studentService.selectCourseByCno(Cno).toString());
			if(studentService.selectCourseByCno(Cno) != null) {//输入的学号存在对应的学生数据
				studentService.removeCourseByCno(Cno);
				model.addAttribute("add_result_info", "删除课程信息成功");
				model.addAttribute("delete_success_flag", 2);
				return "success";
			}else {//输入的学号不为空，但是不存在学号和输入的学号相同的学生
				model.addAttribute("add_result_info", "不存在课程号为" + Cno + "的课程");
				return "course/courseDelete";
			}
		}else {//传入的学生信息为空
			model.addAttribute("add_result_info", "请输入课程号！");					//1 表示传入的 Sno 为空
			return "course/courseDelete";
		}
	}
	
	@RequestMapping("/selectDetailsByCno")
	public String selectDetailsByCno(String Cno,Model model) {
		try {
				if(Cno != null && !Cno.equals("")) {//传入的 Cno 不为空
					if(studentService.selectCourseByCno(Cno) == null) {//学号不为空，但每查询到 学号为 Cno 的课程信息
						model.addAttribute("select_result_info", "未查询到课程号为[" + Cno + "]的课程信息");
						return "course/courseDetails";
					}else {//学号不为空，且查询到了学号为 Cno 的课程信息 
						Course course = studentService.selectDetailsByCno(Cno);
						model.addAttribute("course", course);
						model.addAttribute("select_result_info", "查询课程信息成功");
						model.addAttribute("select_result_flag", true);
						System.out.println("课程详细信息查询过程中获得的课程信息为：" + studentService.selectCourseByCno(Cno).toString());
						return "course/courseDetails";
						}
					}else {
						model.addAttribute("select_result_info", "请输入课程号！");
						return "course/courseDetails";
					}	
		} catch (NullPointerException nullPointerException) {
			model.addAttribute("select_result_info", "请输入课程号！");
			return "course/courseDetails";
		}
		
		
	}
	
	
	//统计模块，根据学号返回 Sc 的 List 集合，并对结果进行统计
	@RequestMapping("/statistic")
	public String statistic(String Cno,Model model) {
		
		model.addAttribute("message", "成绩信息统计");
		model.addAttribute("Cno", Cno);
		try {
			System.out.println("统计过程中课程的详细信息为：" + studentService.selectCourseByCno(Cno).toString());
			if(Cno == null || Cno.equals("")) {//课程号为空
			model.addAttribute("message1", "请输入课程号来进行查询");
			return "statistic";
		}else {//课程号存在
			if(studentService.selectScByCno(Cno) == null) {//输入了课程号，但没有该课程的信息
				model.addAttribute("message1", "未查找到该课程号对应的成绩信息");
				return "statistic";
			}else {//输入了课程号，且查询到了对应的结果
				//res_sc_list 存放符合条件的课程的信息
				//Course selectDetailsByCno(String Cno); 查询课程的详细信息，详细信息可以用于统计
				Course course = studentService.selectDetailsByCno(Cno);
				Integer total_score = 0;
				double average_score = 0;
				Integer level_0= 0 ,level_1= 0 ,level_2 = 0,level_3 = 0;
				List<Sc> scs = course.getScs();
				for(int i = 0; i < scs.size(); i++) {//对 这门 course 的 scs 进行遍历
					int score = scs.get(i).getGrade();
					total_score += score;		//得到总分
					if(score < 60) {
						level_0++;
					}else if(score < 70){
						level_1++;
					}else if(score < 80) {
						level_2++;
					}else {
						level_3++;
					}
				}
				try {
					average_score = total_score/scs.size();		//得到平均分
				} catch (ArithmeticException e) {
					System.out.println("没查询到信息，捕捉除零错误");
					average_score = 0;
				}
				
				model.addAttribute("total", total_score);
				model.addAttribute("average", average_score);
				model.addAttribute("level_0", level_0);
				model.addAttribute("level_1", level_1);
				model.addAttribute("level_2", level_2);
				model.addAttribute("level_3", level_3);
				model.addAttribute("Cname", course.getCname());
				model.addAttribute("scs_list", scs);
				return "statisticResult";
			}
		}
		} catch (NullPointerException e) {
			model.addAttribute("message1", "未能获得所输入课程号的课程信息");
			System.out.println("未能获得所输入课程号的课程信息");
			return "statistic";
		}

	}
	
	@RequestMapping("/courseModify")
	public String modifyCourse(Course course,Model model) {
		System.out.println("课程修改过程中课程的信息为：" + course.toString());
		model.addAttribute("message", "通过课程号修改课程信息");
		model.addAttribute("message1", "修改结果：");
		String Cno = course.getCno();
		model.addAttribute("Cno", Cno);
		
		try {
			if(course.getCno() == null) {
				model.addAttribute("modify_result", "请输入课程号进行课程信息的修改");
				return "course/courseModify";
			}else {//课程信息不为空
				if(studentService.selectCourseByCno(Cno) == null) {//不存在该课程
					model.addAttribute("modify_result", "不存在所输入课程信息所对应的课程信息");
					return "course/courseModify";
				}else {//存在该课程 --> 可以进行修改
					studentService.modifyCourse(course);
					model.addAttribute("modify_success_flag", 2);
					model.addAttribute("modify_result", "课程信息修改成功");
					Course modified_course = studentService.selectCourseByCno(Cno);
					model.addAttribute("course", modified_course);
					return "success";
				}
			}
		} catch (NullPointerException e) {
			System.out.println("第一次进入该页面，输入的课程信息为空");
			return "course/courseModify";
		}
	}
}

5、ScController

package org.student.controller;

import java.util.List;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.student.domain.Sc;
import org.student.service.StudentService;

@Controller
public class ScController {
	@Autowired
	@Qualifier("studentService")
	private StudentService studentService;
	
	/**
	 * 
	 * @param sc
	 * @param model
	 * @return
	 */
	@RequestMapping("/scSelect")
	 public String scSelect(Sc sc,Model model) {
		System.out.println("课程查询过程中接受到的课程信息为：" + sc.toString());
		List<Sc> sc_list = studentService.findScByAllAttr(sc);
			model.addAttribute("message","学生详细信息查询:<hr/>");
			model.addAttribute("message1","查询结果:");
		if( sc_list != null && sc_list.size() != 0) {
			System.out.println("查询到了相应结果"+sc_list+" | | "+ sc_list.size());
			model.addAttribute("res_sc_list", sc_list);
			//如果是第一次进入这个页面，那么默认提交到 selectSc 控制器
			model.addAttribute("post_action", "scSelect");
			//mv.setView(new RedirectView("/StudentsMessageManageSystem/studentSelect"));
		}else {
			System.out.println("查询结果为空"+sc_list+" | | "+sc_list.size());
		}
		return "sc/sc";
	}
	
	/**
	 * 插入课程信息
	 */
	@RequestMapping("/scAdd")
	public String addStudent(Sc sc,Model model) {
		System.out.println("插入课程过程中接受到的课程的详细信息为：" + sc.toString());
		model.addAttribute("sc", sc);
		model.addAttribute("post_action", "scAdd");
		model.addAttribute("message", "添加成绩数据");
		model.addAttribute("message1", "插入的成绩数据为：");
		try {
			if(!sc.getAllAttr()) {//有为空信息
				model.addAttribute("add_result", "请输入信息进行成绩信息的插入");
				return "sc/scAdd";
			}else {//全不为空
				if(studentService.selectCourseByCno(sc.getCno()) == null || studentService.selectStudentBySno(sc.getSno()) == null) {
					//学号或者课程号不存在与之对应的信息
					model.addAttribute("add_result", "输入的学号或课程号不存在与之对应的学生或课程信息");
					return "sc/scAdd";
				}else {//学号和课程号都存在与之对应的信息
					if(studentService.selectScBySnoAndCno(sc.getSno(), sc.getCno()) != null) {//Sc 表中存在 重复的某学生的某课程
						model.addAttribute("add_result", "成绩表中已经存在学生[" + sc.getSno() + "]的" + sc.getCno() + "课程的对应信息：即插入信息重复");
						return "sc/scAdd";
					}else {//Sc 表中不存在重复的信息
						studentService.addSc(sc);
						model.addAttribute("add_success_flag", 3);
						model.addAttribute("add_result", "插入信息成功");
						return "success";
					}
				}
			}
		}catch(NullPointerException nullPointerException) {
			System.out.println("第一次进入该界面，传入的信息为空");
			return "sc/scAdd ";
		}
		
	}
	
	
	@RequestMapping("/scDelete")
	public String scDelete(String Sno, String Cno,  Model model) {
		System.out.println("删除课程过程中，接受到的课程的详细信息为：" + studentService.selectCourseByCno(Cno).toString());
		model.addAttribute("message", "通过学号和课程号删除选课信息");
		model.addAttribute("Cno", Cno);
		model.addAttribute("Sno", Sno);
		if(Sno != null && !Sno.equals("") && Cno != null && !Cno.equals("")) {//传入的学号和课程号不为空
			if(studentService.selectScBySnoAndCno(Sno, Cno) != null) {//输入的学号存在对应的学生数据
				studentService.removeScBySnoAndCno(Sno, Cno);
				model.addAttribute("add_result_info", "删除选课信息成功");
				model.addAttribute("delete_success_flag", 3);
				return "success";
			}else {//输入的学号和课程号都不为空，但是不存在输入的学号和课程号所对应的选课信息
				model.addAttribute("add_result_info", "不存在学号为" + Sno + "的学生，所选课为" + Cno + "的选课信息");
				return "sc/scDelete";
			}
		}else {//传入的学生信息为空
			model.addAttribute("add_result_info", "请输入学号及其对应的课程号！");					//1 表示传入的 Sno 或 Cno 为空
			return "sc/scDelete";
		}
	}
	
	@RequestMapping("/scModify")
	public String scModify(Sc sc,Model model) {
		System.out.println("修改课程过程中，获得的课程的详细信息为：" + sc.toString());
		model.addAttribute("message", "成绩信息修改");
		model.addAttribute("message1", "修改结果：");
		try {
			if(sc.getSno() == null || sc.getCno() == null) {//学号或课程号任意一个为空
				model.addAttribute("modify_result", "请输入课程号和学号对成绩信息进行修改");
				return "sc/scModify";
			}else {//都不为空
				if(studentService.selectScBySnoAndCno(sc.getSno(), sc.getCno()) == null) {//不存在对应的信息
					model.addAttribute("modify_result", " 不存在所输入的学号及课程号对应的成绩信息");
					return "sc/scModify";
				}else {//学号和课程号都存在
					if(sc.getGrade() < 0 || sc.getGrade() > 100) {
						model.addAttribute("modify_result", "请输入在 0 到 100 之间的有效成绩");
						return "sc/scModify";
					}else {
						studentService.modifySc(sc);
						Sc modified_sc = studentService.selectScBySnoAndCno(sc.getSno(), sc.getCno());
						model.addAttribute("sc", modified_sc);
						model.addAttribute("modify_success_flag", 3);
						model.addAttribute("modify_result", "修改成绩信息成功");
						return "success";
					}
				}
			}
		} catch (NullPointerException e) {
			System.out.println("第一次进入页面，输入的成绩信息为空");
			return "sc/scModify";
		}
	}
	
}

Service层

所有的 service 都在一个类里面
1、studentService

package org.student.service;

import java.util.List;

import org.student.domain.*;

public interface StudentService {
	//******************************信息管理系统用户User相关*******************************
	
	User login(String username,String password);
	
	//******************************学生基本信息Student相关*******************************

	List<Student> findStudentByAllAttr(Student student);

	Student selectStudentBySno(String Sno);

	void addStudent(Student student);

	void modifyStudent(Student student);

	void removeStudentBySno(String Sno);
	
	//******************************课程基本信息Course相关*******************************

	List<Course> findCourseByAllAttr(Course course);

	Course selectCourseByCno(String Cno);

	void addCourse(Course course);

	void modifyCourse(Course course);

	void removeCourseByCno(String Cno);
	
	Course selectDetailsByCno(String Cno);
	//******************************选课表基本信息SC相关*******************************

	List<Sc> findScByAllAttr(Sc sc);

	Sc selectScBySnoAndCno(String Sno, String Cno);

	List<Sc> selectScByCno(String Cno);

	void addSc(Sc sc);

	void modifySc(Sc sc);

	void removeScBySnoAndCno(String Sno, String Cno);	
	
}

2、service的实现类

package org.student.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.student.dao.CourseDao;
import org.student.dao.ScDao;
import org.student.dao.StudentDao;
import org.student.dao.UserDao;
import org.student.domain.Course;
import org.student.domain.Sc;
import org.student.domain.Student;
import org.student.domain.User;
import org.student.service.StudentService;
/**
 * @Description: 学生信息管理系统的StudentService接口的实现类
 * @author NAIL
 *
 */

@Service("studentService")
public class StudentServiceImpl implements StudentService{
	/**
	 * 自动注入持久层Dao对象
	 */
	@Autowired
	private UserDao userDao;
	
	@Autowired
	private StudentDao studentDao;
	
	@Autowired
	private CourseDao courseDao;
	
	@Autowired
	private ScDao scDao;
	
	
	//*****************接口中抽象方法的实现******************
	@Override	//已实现
	public User login(String loginname, String password) {
		return userDao.selectByLoginnameAndPassword(loginname, password);
	}

	@Override	//插入学生，已经实现
	public void addStudent(Student student) {
		studentDao.save(student);
	}

	@Override	//已实现
	public void modifyStudent(Student student) {
		studentDao.modifyStudent(student);;
	}

	@Override	//已实现
	public void removeStudentBySno(String Sno) {
		studentDao.removeStudentBySno(Sno);
	}
//*****************************Course相关*****************************(


	@Override	//已实现
	public void addCourse(Course course) {
		courseDao.save(course);
	}

	@Override	//已实现
	public void modifyCourse(Course course) {
		courseDao.modifyCourse(course);
		
	}

	@Override	//已实现
	public void removeCourseByCno(String Cno) {
		courseDao.removeCourse(Cno);
	}
	
	@Override	//已实现
	public void addSc(Sc sc) {
		scDao.save(sc);
	}

	@Override	//已实现
	public void modifySc(Sc sc) {
		scDao.modifySc(sc);
	}

	@Override	//已实现
	public void removeScBySnoAndCno(String Sno, String Cno) {
		scDao.removeSc(Sno, Cno);		
	}

	@Override	//已实现
	public List<Student> findStudentByAllAttr(Student student ) {
		return studentDao.findStudentByAllAttr(student);
	}

	@Override	//已实现
	public List<Course> findCourseByAllAttr(Course course) {
		return courseDao.findCourseByAllAttr(course);
	}

	@Override	//已实现
	public List<Sc> findScByAllAttr(Sc sc) {
		return scDao.findScByAllAttr(sc);
	}

	@Override	//已实现
	public Student selectStudentBySno(String Sno) {
		return studentDao.selectStudentBySno(Sno);
	}

	@Override	//已实现
	public Course selectCourseByCno(String Cno) {
		return courseDao.selectCourseByCno(Cno);
	}

	@Override	//已实现
	public Sc selectScBySnoAndCno(String Sno, String Cno) {
		return scDao.selectScBySnoAndCno(Sno, Cno);
	}

	@Override	//已实现
	public Course selectDetailsByCno(String Cno) {
		return courseDao.selectDetailsByCno(Cno);
	}

	@Override	//已实现 | 不用于 WEB ，用于辅助其他函数的实现
	public List<Sc> selectScByCno(String Cno) {
		return scDao.selectScDetailsByCno(Cno);
	}

}

Dao层

1、userDao

package org.student.dao;

import org.student.domain.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
/**
 * @Description: UserMapper 接口
 * @author NAIL
 */
public interface UserDao{
	
	@Select("select * from User where loginname = #{loginname} and password = #{password}")
	User selectByLoginnameAndPassword(
			@Param("loginname") String loginname,
			@Param("password") String password);
/**
	@Select("select * from User where loginname = #{loginname}")
	User selectByLoginname(
			@Param("loginname") String loginname);

	@SelectProvider(type=UserDynaSqlProvider.class,method="insertUser")
	void save(User user);
*/
}

2、studentDao

package org.student.dao;

import java.util.List;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.UpdateProvider;
import org.student.dao.provider.StudentDynaSqlProvider;
import org.student.domain.Student;

public interface StudentDao {
	//查
    @SelectProvider(type=StudentDynaSqlProvider.class,method="selectByAllAttr")
	List<Student> findStudentByAllAttr(Student student );
	//查
    @Select("select * from student where Sno = #{Sno}")
    Student selectStudentBySno(String Sno);
    //删
   @Delete("delete from student where Sno = #{Sno}")
	void removeStudentBySno(String Sno);
    //改 update student set sno = xxx, sname = xxx, ssex = xxx, sage = xxx, sdept = xxx where sno = yyy;
   @UpdateProvider(type=StudentDynaSqlProvider.class,method="modifyStudent")
	void modifyStudent(Student student);
	//插
	@SelectProvider(type=StudentDynaSqlProvider.class,method="insertStudent")
	void save(Student student);

}

3、ScDao

package org.student.dao;

import java.util.List;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.InsertProvider;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.UpdateProvider;
import org.student.dao.provider.ScDynaSqlProvider;
import org.student.domain.Sc;

public interface ScDao {
	//查
    @SelectProvider(type=ScDynaSqlProvider.class,method="selectByAllAttr")
	List<Sc> findScByAllAttr(Sc sc);
    //查
    @Select("select * from sc where 1=1 and Sno = #{Sno} and Cno = #{Cno}")
    Sc selectScBySnoAndCno(@Param("Sno") String Sno, @Param("Cno") String Cno);
    //增
    @InsertProvider(type=ScDynaSqlProvider.class,method="insertSc")
    void save(Sc sc);
    //通过学号和课程号删除成绩信息
    @Delete("delete from sc where Sno = #{Sno} and Cno = #{Cno}")
    void removeSc(@Param("Sno") String Sno, @Param("Cno") String Cno);
    @Results({
    		@Result(column = "Cno", property = "cno", id = true),
    		@Result(column = "Sno", property = "sno", id = true),
    		@Result(column = "Grade", property = "grade", id = false),
    		//对 student 表的外键的查询实现
    		@Result(column = "Sno", property = "student",
    				one = @One(select = "org.student.dao.StudentDao.selectStudentBySno"))
    })
    @Select("select * from Sc where Cno = #{Cno}")
    List<Sc> selectScDetailsByCno(String Cno);			//进行了多对一的关系的配置，查询到的结果为 Sc 的基本信息，和学生的姓名
	
    @UpdateProvider(type=ScDynaSqlProvider.class,method="modifySc")
    void modifySc(Sc sc);
    
}

4、CourseDao

package org.student.dao;

import java.util.List;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.InsertProvider;
import org.apache.ibatis.annotations.Many;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.UpdateProvider;
import org.student.dao.provider.CourseDynaSqlProvider;
import org.student.domain.Course;

public interface CourseDao {
	//查
	@SelectProvider(type=CourseDynaSqlProvider.class,method="selectByAllAttr")
	List<Course> findCourseByAllAttr(Course course);
	//查
	@Select("select * from course where cno = #{Cno}")
	Course selectCourseByCno(String cno);
	//查：根据课程号查询课程的详细信息
	@Results({//@Results 注解，存放 @Result 注解的列表
		//column为数据库字段名，porperty为实体类属性名
		@Result(column = "Cno", property = "cno", id = true), 	//id = true 表示主键
		@Result(column = "Cname", property = "cname"), 
		@Result(column = "Ccredit", property = "ccredit"),
		/*
		 * @One的用法。当我们需要通过查询到的一个字段值作为参数，去执行另外一个方法来查询关联的内容，
		 * 而且两者是一对一关系时，可以使用@One注解来便捷的实现。
		 * 
		 * @Many 的用法。与@One类似，只不过如果使用@One查询到的结果是多行，
		 * 会抛出TooManyResultException异常，这种时候应该使用的是@Many注解，实现一对多的查询。
		 * 
		 * 由于Course 表中，没有Student 表的外键，我认为 Course 和 Student 表没有直接的关系
		 */
		//一个 Course 对应多个 Student， 一个Course 对应多个 成绩 Sc
		//先对成绩信息进行查
		@Result(column = "Cno", property = "scs", 
		many=@Many(
				select="org.student.dao.ScDao.selectScDetailsByCno"
				))
	})
	@Select("select * from course where cno = #{Cno} ")
	Course selectDetailsByCno(String Cno);
	//删
	@Delete("delete from course where cno = #{Cno}")
	void removeCourse(String Cno);
	@UpdateProvider(type=CourseDynaSqlProvider.class,method="modifyCourse")
	void modifyCourse(Course course);
	//插
	@InsertProvider(type=CourseDynaSqlProvider.class,method="insertCourse")
	void save(Course course);
}

Dao 层实现类

1、User

package org.student.dao.provider;

import org.apache.ibatis.jdbc.SQL;
import org.student.domain.User;

public class UserDynaSqlProvider {
public String insertUser(User user){
		
		return new SQL(){
			{
				INSERT_INTO("user");
				if(user.getLoginname() != null && !user.getLoginname().equals("")){
					VALUES("loginname", "#{loginname}");
				}
				if(user.getPassword() != null && !user.getPassword().equals("")){
					VALUES("password", "#{password}");
				}
			}
		}.toString();
	}
}

2、Student

package org.student.dao.provider;

import org.apache.ibatis.jdbc.SQL;
import org.student.domain.Student;
/*
 * 	private String Sno;
	private String Sname;
	private String Ssex;
	private int Sage;
	private String Sdept;
 */
public class StudentDynaSqlProvider {
	
	/*
	 * 动态实现对查询条件的拼接，动态SQL语句
	 */
	public String selectByAllAttr(Student student) {
		//根据学生的已知条件来查询学生的详细信息，对姓名、学号、班级、系名等支持模糊查询
		//返回的sql语句
		StringBuffer dySql = new StringBuffer("select * from student where 1=1");
		
		//对对象的具体参数进行判断，并对动态SQL语句进行拼接
		// = 部分
		if(student.getSsex() != null && !("".equals(student.getSsex()))) {
			dySql.append(" AND Ssex = '" + student.getSsex() + "' ");
		}
		if(student.getSage() != null) {
			dySql.append(" AND Sage = " + student.getSage() + " ");
		}
		//LIKE 部分
		if(student.getSno() != null && !("".equals(student.getSno()))) {
            dySql.append(" AND Sno LIKE '%" + student.getSno() + "%'");
		}
		if(student.getSdept()!=null && !("".equals(student.getSdept()))) {
            dySql.append(" AND Sdept LIKE '%" + student.getSname() + "%'");
		}
		if(student.getSname()!=null && !("".equals(student.getSname()))) {
            dySql.append(" AND Sname LIKE '%" + student.getSname() + "%'");
		}
		System.out.println("全属性查询中的查询语句为："+dySql.toString());
		return dySql.toString();
	}
	
	
	public String insertStudent(Student student) {
		String sql = new SQL(){
			{
				INSERT_INTO("student");
				if(student.getSname() != null && !student.getSname().equals("")){
					VALUES("Sname", "'" + student.getSname() + "'");
				}
				if(student.getSno() != null && !student.getSno().equals("")){
					VALUES("Sno", "'" + student.getSno() + "'");
				}
				if(student.getSsex() != null && !student.getSsex().equals("")){
					VALUES("Ssex", "'" + student.getSsex() + "'");
				}
				if(student.getSage() != null) {
					VALUES("Sage", student.getSage().toString());
				}
				
				if(student.getSdept() != null && !student.getSdept().equals("")){
					VALUES("Sdept", "'" + student.getSdept() + "'");
				}
			}
		}.toString();
		System.out.println("插入学生信息输出语句："+sql);
		return sql;
	}
	
	
	public String modifyStudent(Student student) {
		String sql = new SQL(){
			{
				UPDATE("student");
				if(student.getSname() != null && !student.getSname().equals("")) {
					SET(" Sname =  '" + student.getSname() + "' ");
				}
				if(student.getSsex() != null && !student.getSsex().equals("")) {
					SET(" Ssex = '" + student.getSsex() + "' ");
				}
				if(student.getSdept() != null && !student.getSdept().equals("")) {
					SET(" Sdept = '" + student.getSdept() + "' ");
				}
				if(student.getSage() != null) {
					SET(" Sage = " + student.getSage());
				}
				WHERE("Sno = '" + student.getSno() + "' ");
			}
		}.toString();
		System.out.println("修改学生信息输出语句："+sql);
		return sql;
	}
	
}

3、Course实现类

package org.student.dao.provider;

import org.apache.ibatis.jdbc.SQL;
import org.student.domain.Course;

public class CourseDynaSqlProvider {
	/**
	 * 查询课程表的基本信息
	 * @param course
	 * @return
	 */
	public String selectByAllAttr(Course course) {
		//返回的sql语句
		StringBuffer dySql = new StringBuffer("select * from course where 1=1");
		
		//对对象的具体参数进行判断，并对动态SQL语句进行拼接
		// = 部分
		if(course.getCno() != null && !("".equals(course.getCno()))) {
			dySql.append(" AND Cno = '" + course.getCno() + "' ");
		}
		if(course.getCpno() != null && !("".equals(course.getCpno()))) {
			dySql.append(" AND Cpno = '" + course.getCpno() + "' ");
		}
		if(course.getCcredit() != null) {
			dySql.append(" AND Ccredit = " + course.getCcredit());
		}

		//LIKE 部分
		if(course.getCname()!=null && !("".equals(course.getCname()))) {
            dySql.append(" AND Cname LIKE '%" + course.getCname() + "%'");
		}
		System.out.println("全属性查询中的查询语句为："+dySql.toString());
		return dySql.toString();
	}
	
	public String insertCourse(Course course) {
		String sql = new SQL(){
			{
				INSERT_INTO("course");
				if(course.getCname() != null && !course.getCname().equals("")){
					VALUES("Cname", "'" + course.getCname() + "'");
				}
				if(course.getCno() != null && !course.getCno().equals("")){
					VALUES("Cno", "'" + course.getCno() + "'");
				}
				if(course.getCpno() != null && !course.getCpno().equals("")){
					VALUES("Cpno", "'" + course.getCpno() + "'");
				}
				if(course.getCcredit() != null) {
					VALUES("Ccredit", course.getCcredit().toString());
				}
			}
		}.toString();
		System.out.println("插入课程信息输出语句："+sql);
		return sql;
	}
	
	
	/**
	 * 根据课程号查找课程的详细信息 
	 * @param cno
	 * @return
	 */
	public String selectDetailsByCno(String Cno) {

		StringBuffer dySql = new StringBuffer("select SC.Cno,Cname,SC.Sno,Sname,Ccredit,Grade from student,course,sc "
				+ "where course.Cno=sc.Cno and student.Sno=sc.Sno ");			//ORDER BY Cname
		if(Cno != null && !Cno.equals("")) {
			dySql.append(" and course.Cno = '" + Cno +"' ");
		}
		dySql.append(" order by Cno ");
		System.out.println("查找课程详细信息的语句为："+ dySql.toString());
		return dySql.toString();
	}
	
	
	public String modifyCourse(Course course) {
		String sql = new SQL(){
			{
				UPDATE("course");
				if(course.getCname() != null && !course.getCname().equals("")) {
					SET(" Sname =  '" + course.getCname() + "' ");
				}
				if(course.getCpno() != null && !course.getCpno().equals("")) {
					SET(" Cpno = '" + course.getCpno() + "' ");
				}
				if(course.getCcredit() != null) {
					SET(" Ccredit = '" + course.getCcredit() + "' ");
				}
				WHERE("Cno = '" + course.getCno() + "' ");
			}
		}.toString();
		System.out.println("修改课程信息输出语句："+sql);
		return sql;
	}
	
}

4、Sc实现类

package org.student.dao.provider;

import org.apache.ibatis.jdbc.SQL;
import org.student.domain.Sc;

public class ScDynaSqlProvider {
	//动态 SQL 语句
	public String selectByAllAttr(Sc sc) {
		//返回的sql语句
		StringBuffer dySql = new StringBuffer("select * from sc where 1=1");
		
		//对对象的具体参数进行判断，并对动态SQL语句进行拼接
		// = 部分
		if(sc.getSno() != null && !("".equals(sc.getSno()))) {
			dySql.append(" AND Sno = '" + sc.getSno() + "' ");
		}
		if(sc.getCno() != null && !("".equals(sc.getCno()))) {
			dySql.append(" AND Cno = '" + sc.getCno() + "' ");
		}
		if(sc.getGrade() != null) {
			dySql.append("AND Grade = " + sc.getGrade());
		}
		 
		System.out.println("全属性查询中的查询语句为："+dySql.toString());
		return dySql.toString();
	}
	
	public String insertSc(Sc sc) {
		String sql = new SQL(){
			{
				INSERT_INTO("sc");
				if(sc.getSno() != null && !sc.getSno().equals("")){
					VALUES("Sno", "'" + sc.getSno() + "'");
				}
				if(sc.getCno() != null && !sc.getCno().equals("")){
					VALUES("Cno", "'" + sc.getCno() + "'");
				}
				if(sc.getGrade() != null){
					VALUES("Grade", sc.getGrade().toString());
				}
			}
		}.toString();
		System.out.println("插入课程信息输出语句："+sql);
		return sql;
	}
	
	
	public String modifySc(Sc sc) {
		String sql = new SQL(){
			{
				UPDATE("sc");
				if(sc.getGrade() != null) {
					SET(" Grade =  '" + sc.getGrade() + "' ");
				}
				WHERE("Cno = '" + sc.getCno() + "' AND Sno = '" + sc.getSno() + "' ");
			}
		}.toString();
		System.out.println("修改课程信息输出语句："+sql);
		return sql;
	}
	
}

拦截器

package org.student.interceptor;

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

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.student.domain.User;
//创建 Spring Mvc 的拦截器，避免直接通过 URL 访问资源
public class studentInterceptor implements HandlerInterceptor{
	
	private static final String[] IGNORE_URL = {"/loginForm","/login"};	
	
	//在 perHandle 方法返回值为 true 时才会执行
	@Override
	public void afterCompletion(HttpServletRequest request,
			HttpServletResponse response, Object handler, Exception exception)
				throws Exception{
		
	}
	
	
	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response,
			Object object, ModelAndView mv) throws Exception{
		
	}
	
	
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
			Object handler) throws Exception {
		
		boolean flag = false;
		
		String servletPath = request.getServletPath();
		for (String s : IGNORE_URL) {
            if (servletPath.contains(s)) {
                flag = true;
                break;
            }
        }
		
		if (!flag){
        	/** 1.获取session中的用户  */
        	User user = (User) request.getSession().getAttribute("user_session");
        	/** 2.判断用户是否已经登录 */
        	if(user == null){
        		 /** 如果用户没有登录，跳转到登录页面 */
        		request.setAttribute("message", "请先登录再访问网站!");
        		request.getRequestDispatcher("loginForm").forward(request, response);
        		return flag;
        	}else{
        		 flag = true;
        	}
        }
        return flag;
		
	}
}

jsp

1、主页

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<!-- style 标签应该写到 head 标签里面，否则报警告 -->
<style type="text/css">
<!--

a:link {
 color: #00FF00;
 text-decoration: none;
}
a:visited {
 color: #00FF00;
 text-decoration: none;
}
a:hover {
 color: #00FF00;
 text-decoration: underline;
}

-->
</style>
<meta charset="UTF-8">
<title>学生信息管理系统 | 菜单</title>
</head>
<body>

<table  border="1">
		<tr >
			<th colspan="9"><h1>数据信息类型</h1></th>
		</tr>
		<tr>
			<th><h2>单表查询</h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/studentSelect">查询学生信息</a></h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/courseSelect">查询课程信息</a></h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/scSelect">查询选课信息</a></h2></th>
		</tr>	
		<tr>
			<th><h2>添加信息</h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/studentAdd">添加学生信息</a></h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/courseAdd">添加课程信息</a></h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/scAdd">添加选课信息</a></h2></th>
		</tr>	
		<tr>
			<th><h2>删除信息</h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/studentDelete">删除学生信息</a></h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/courseDelete">删除课程信息</a></h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/scDelete">删除选课信息</a></h2></th>
		</tr>
		<tr>
			<th><h2>课程信息</h2></th>
			<th colspan="4"><h2><a href="/StudentsMessageManageSystem/selectDetailsByCno">根据课程的基本信息(学号)查询课程的详细信息</a></h2></th>
		</tr>
		<tr>
			<th><h2>统计图表</h2></th>
			<th colspan="4"><h2><a href="/StudentsMessageManageSystem/statistic">根据课程号统计课程的详细信息</a></h2></th>
		</tr>		
		<tr>
			<th><h2>修改信息</h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/studentModify">修改学生信息</a></h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/courseModify">修改课程信息</a></h2></th>
			<th><h2><a href="/StudentsMessageManageSystem/scModify">修改选课信息</a></h2></th>
		</tr>	
	</table>
</body>
</html>