java web开发入门汇总
servlet
用java语言开发动态资源网站的技术，在doGet方法中拼接显示html，在doPost方法中提交数据。类似于.net的ashx技术。
servlet生成的class文件存放在tomcat中webapps目录下。
1.开发一个servlet步骤：
1）在src下新建包并编写java类，继承HttpServlet类
2）重写doGet和doPost方法
package com.eggtwo.boss; import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; @WebServlet("/test")
public class TestServlet extends HttpServlet {
private static final long serialVersionUID = 1L; public TestServlet() {
super();
} protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException { response.getWriter().append("Served at: ").append(request.getContextPath());
} protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
} }
2.servlet的生命周期
构造方法： 创建servlet对象的时候调用。默认情况下，第一次访问servlet的时候创建servlet对象 只调用1次。证明servlet对象在tomcat是单实例的。
init方法： 创建完servlet对象的时候调用。只调用1次。
service方法： 每次发出请求时调用。调用n次。
destroy方法： 销毁servlet对象的时候调用。停止服务器或者重新部署web应用时销毁servlet对象。 只调用1次。
JSP
1.特点：
用java语言+html开发动态网站的技术。jsp就是servlet（）。
类似于.net的webform，jsp页面可以java语言和html混合写。
tomcat的work目录存放jsp运行的临时文件（.java和.class文件），在运行jsp页面时动态生成并 执行。
访问方式：http://localhost:8080/javaweb/hello.jsp
2.创建方式：
在WebRoot下创建jsp页面。
<%@page import="java.util.Date"%>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<%
out.write("hello");
Date dt=new Date();
String s=dt.toLocaleString();
%>
<h3><%=s %></h3>
</body>
</html>
3.生命周期：
1）翻译： jsp->java文件
2）编译： java文件->class文件（servlet程序）
3）构造方法（第1次访问）
4）init方法（第1次访问）：_jspInit()
5）service方法：_jspService()
6）destroy方法：_jspDestroy()
4.jsp语法
4.1jsp表达式：
语法：<%=变量或表达式%>
作用： 向浏览器输出变量的值或表达式计算的结果
注意：
1）表达式的原理就是翻译成out.print(“变量” );通过该方法向浏览器写出内容
2）表达式后面不需要带分号结束。
4.2jsp脚本
语法：<% java代码 %>
作用： 执行java代码
注意：原理把脚本中java代码原封不动拷贝到_jspService方法中执行，不能声明方法
4.3jsp的声明
语法：<%! 变量或方法 %>
作用： 声明jsp的变量或方法
注意:
1）变量翻译成成员变量，方法翻译成成员方法。
4.4jsp的注释
语法： <%-- jsp注释 --%>
注意;
1)html的注释会被翻译和执行。而jsp的注释不能被翻译和执行。
4.5jsp指令
include指令：
作用： 在当前页面用于包含其他页面，类似于.net mvc中的分布视图
语法： <%@include file="common/header.jsp"%>
注意：
1）原理是把被包含的页面（header.jsp）的内容翻译到包含页面(index.jsp)中,合并成翻译成一 个java源文件，再编译运行！！，这种包含叫静态包含（源码包含）
2）如果使用静态包含，被包含页面中不需要出现全局的html标签了！！！（如html、head、 body）
page指令：
作用： 告诉tomcat服务器如何翻译jsp文件
<%@ page
language="java" --告诉服务器使用什么动态语言来翻译jsp文件
import="java.util.*" --告诉服务器java文件使用什么包导入包，多个包之间用逗号分割
pageEncoding="utf-8" --告诉服务器使用什么编码翻译jsp文件（成java文件）
contentType="text/html; charset=utf-8" 服务器发送浏览器的数据类型和内容编码，注意：在开发工具中，以后只需要设置pageEncoding即可解决中文乱码问题
errorPage="error.jsp" --指定当前jsp页面的错误处理页面。
isErrorPage="false" --指定当前页面是否为错误处理页面。false，不是错误处理页面，则不能使用exception内置对象；true，是错误处理页面，可以使用exception内置对象。
buffer="8kb" --jsp页面的缓存区大小
session="true" --是否开启session功能。false，不能用session内置对象；true，可以使用session内置对象。
isELIgnored="false" --是否忽略EL表达式
%>
配置全局的错误处理页面：
在web.xml中的web-app节点下配置：
<!-- 全局错误处理页面配置 -->
<error-page>
<error-code>500</error-code>
<location>/common/500.jsp</location>
</error-page>
<error-page>
<error-code>404</error-code>
<location>/common/404.html</location>
</error-page>
5.jsp内置对象
JSP内置对象(9个内置对象):
1.pageContext javax.servlet.jsp.PageContext JSP的页面容器
2.request javax.servlet.http.HttpServletrequest 获取用户的请求信息
3.response javax.servlet.http.HttpServletResponse 服务器向客户端的回应信息
4.session javax.servlet.http.HttpSession 用来保存每一个用户的信息
5.application javax.servlet.ServletContext 表示所有用户的共享信息
6.config javax.servlet.ServletConfig 服务器配置信息，可以取得初始化参数
7.out javax.servlet.jsp.jspWriter 页面输出
8.page (java.lang.object)
9.exception java.lang.Throwable
4个域对象的范围:用于共享数据（设置、获取、删除）
page(pageContext):只在当前jsp页面中有效， 跳转之后无效。
request:只在一次请求中有效，服务器跳转(转发)之后有效。 客户端跳无效
session:在一次会话中有效。服务器跳转、客户端跳转都有效。 网页关闭重新打开无效
application:在整个服务器上保存，所有用户都可使用。 重启服务器后无效
<%
pageContext.setAttribute("age", 18);
pageContext.setAttribute("tom", 11,pageContext.REQUEST_SCOPE);
request.setAttribute("name","jack");
session.setAttribute("lily", 12);
application.setAttribute("全局",12); %>
<h1>${name}</h1>
<h1>${tom}</h1>
<h1>${age}</h1>
<h1>${lily}</h1>
<h1>${全局}</h1>
域对象保存值，取值，删除的方法
//设置值
pageContext.setAttribute("age", 18);
//取值
Object obj=pageContext.getAttribute("age");
if(obj==null){
out.write("已删除");
}else{
//数字直接试用out.write输出会乱码
int age=Integer.parseInt(obj.toString());
out.write(Integer.toString(age));
//或者
//out.write(obj.toString());
}
out.write("<br/>");
pageContext.removeAttribute("age");
Object obj1=pageContext.getAttribute("age");
if(obj1==null){
out.write("已删除");
}else{
out.write(obj1.toString());
}
注意：如果设置过多的application属性范围会影响服务器性能。
pageContext.PAGE_SCOPE
pageContext.REQUEST_SCOPE
pageContext.SESSION_SCOPE
pageContext.APPLICATION_SCOPE
pageContext.setAttribute("name", "liuyang", pageContext.APPLICATION_SCOPE);
6.EL表达式
6.1 作用
jsp的核心语法： jsp表达式 <%=%>和 jsp脚本<% %>。
以后开发jsp的原则： 尽量在jsp页面中少写甚至不写java代码。
使用EL表达式替换掉jsp表达式
EL表达式作用： 向浏览器输出域对象中的变量值或表达式计算的结果！！！
语法： ${变量或表达式}
6.2EL语法
1）输出基本数据类型变量
1.1 从四个域获取
${name}
1.2 指定域获取
${pageScope.name}
1.3 输出对象属性：student.name 注意：.name 相当于 getName()方法，其中name和Name要对应
域范围： pageScoep / requestScope / sessionScope / applicationScope
2）处理集合${studentList[0].name}
3)表达式计算 ${10+1}
7.jsp标签
7.1 jsp标签作用：
替换jsp脚本
7.2 Jsp标签分类：
1）内置标签（动作标签）： 不需要在jsp页面导入标签
2）jstl标签： 需要在jsp页面中导入标签
3）自定义标签 ： 开发者自行定义，需要在jsp页面导入标签
内置标签（动作标签）：
转发标签： <jsp:forward />
参数标签： <jsp:pararm/>
例如：内部跳转到second.jsp并带上参数name=jack
<jsp:forward page="second.jsp">
<jsp:param value="name" name="jack"/>
</jsp:forward>
等同于
request.getRequestDispatcher("second.jsp?name=jack").forward(request, response);
包含标签： <jsp:include/>
<%@include file="common.jsp" %>
<jsp:include page="comm.jsp">
<jsp:param value="name" name="jack"/>
</jsp:include>
静态包含语法： <%@inclue file="被包含的页面"%>
动态包含语法： <jsp:include page="被包含的页面">
静态包含： 先合并再翻译
动态包含： 先翻译再合并
7.3 JSTL标签
JSTL (全名：java standard tag libarary - java标准标签库 )
五套标签库：
1.核心标签库 （c标签库） 天天用
2.国际化标签（fmt标签库）
3.EL函数库（fn函数库）
4.xml标签库（x标签库）
5.sql标签库（sql标签库）
使用JSTL标签步骤
1） Eclispe需要导入jstl支持的jar包（标签背后隐藏的java代码）注意：MyEclispe使用javaee5.0的项目自动导入jstl支持jar包
eclispe导入方式：将standard.jar和jstl.jar文件拷贝到工程的\WEB-INF\lib\下，然后build path
2）使用taglib指令导入标签库 <%@taglib uri="tld文件的uri名称" prefix="简写" %>
例如：在jsp页面导入核心标签库：
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
3）在jsp中使用jstl标签
保存数据： <c:set></c:set>
<%--
set标签：保存值到域中
var:值的名称
value：值
scope:值的范围，page,request,session,application
--%>
<c:set var="sex" value="man" scope="request"></c:set>
获取数据：<c:out value=""></c:out>
<%--
out标签：获取域中设置的数据
default：当value为null时，使用默认值
escapeXml:是否对value进行转义，false不转义，true转义
--%>
<c:out value="${sex}" default="<h1>默认值</h1>" escapeXml="true"></c:out>
单条件判断： <c:if test=""></c:if>
<%--if标签：单条件判断 --%>
<c:if test="${5>3}">
多条件判断：
<c:choose></c:choose>
<c:when test=""></c:when>
<c:otherwise></c:otherwise>
<c:set var="score" value="80"></c:set>
<c:choose>
<c:when test="${score>90}">
优秀
</c:when>
<c:when test="${score<=90&&score>60}">
良好
</c:when>
<c:otherwise>
差
</c:otherwise>
</c:choose>
循环数据：
<c:forEach></c:forEach>
<%
ArrayList<String> list=new ArrayList<String>();
list.add("tom");
list.add("jack");
list.add("jack");
pageContext.setAttribute("list", list);
%>
<%--forEach循环
begin:从哪个元素开始，默认从0开始
end:到哪个元素结束
step:每次的增量
items：要遍历的数据
var：每个元素的名称
varStatus:正在遍历的元素的状态对象，count属性默认从1开始
--%>
<c:forEach begin="0" end="2" step="1" items="${list}" var="names" varStatus="varSta">
<h4>顺序：${varSta.count}，${names}</h4>
</c:forEach>
<c:forTokens items="" delims="" var=""></c:forTokens>
<%
String sps="a-b-c";
pageContext.setAttribute("sps",sps);
%>
<c:forTokens items="${sps}" delims="-" var="ss">
<h5>${ss}</h5>
</c:forTokens>
重定向：<c:redirect url=""></c:redirect>
<c:redirect url="http://www.baidu.com"> </c:redirect>
7.4 自定义标签
开发步骤：
1.
编写一个普通的java类，继承SimpleTagSupport类，叫标签处理器类
public class ShowIpTag extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
// 向浏览器输出客户的ip地址
PageContext pageContext = (PageContext) getJspContext();
HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
String ip = request.getRemoteHost();
JspWriter out = pageContext.getOut();
out.write("使用自定义标签输出客户IP地址：" + ip);
}
}
2）在web项目的WEB-INF目录下建立eggtwo.tld文件，这个tld叫标签库的声明文件。（参考核心标签库的tld文件）
<?xml version="1.0" encoding="UTF-8" ?> <taglib xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
version="2.1">
<!-- 标签库版本 -->
<tlib-version>1.1</tlib-version>
<!-- 标签库前缀版本 -->
<short-name>eggtwo</short-name>
<!--tld文件的唯一标记，完整的uri -->
<uri>http://tag.eggtwo.com</uri>
<tag>
<!--标签名称tld文件的唯一标记 -->
<name>showIp</name>
<!--标签处理器类的全称（包名+类名） -->
<tag-class>com.eggtwo.boss.ShowIpTag</tag-class>
<!--输出内容的格式 -->
<body-content>scriptless</body-content> </tag>
</taglib>
3） 在jsp页面的头部导入自定义标签库
<%@taglib prefix="eggtwo" uri="http://tag.eggtwo.com" %>
4） 在jsp中使用自定义标签
<eggtwo:showIp></eggtwo:showIp>
JavaBean
JavaBean, 咖啡豆。 JavaBean是一种开发规范，可以说是一种技术。
JavaBean就是一个普通的java类。只有符合以下规定才能称之为javabean：
1）必须提供无参数的构造方法
2）类中属性都必须私有化(private)
3）该类提供公开的getter 和 setter方法
getName() setName(String name)
注意： boolean类型的get方法名称叫 isXXX()方法 public boolean isAcitve()
JavaBean的作用： 用于封装数据，保存数据。
访问javabean只能使用getter和setter方法
JavaBean的使用场景：
1）项目中用到实体对象（entity）符合javabean规范
2）EL表达式访问对象属性。${student.name} 调用getName()方法，符合javabean规范。
3）jsp标签中的属性赋值。 setNum（Integer num）。符合javabean规范。
4）jsp页面中使用javabean。符合javabean规范
mysql
struts
struts是对servlet的封装
1.开发步骤
1.下载struts 开发库：http://struts.apache.org 下载点击下载：struts-*-all.zip版本 ，使用2.3版本
2.在项目lib下面导入struts必须的包，然后build path
commons-fileupload-1.2.2.jar 【文件上传相关包】
commons-io-2.0.1.jar
struts2-core-2.3.4.1.jar 【struts2核心功能包】
xwork-core-2.3.4.1.jar 【Xwork核心包】
ognl-3.0.5.jar 【Ognl表达式功能支持表】
commons-lang3-3.1.jar 【struts对java.lang包的扩展】
freemarker-2.3.19.jar 【struts的标签模板库jar文件】
javassist-3.11.0.GA.jar 【struts对字节码的处理相关jar】
3.配置web.xml
<!-- 引入struts核心过滤器 -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
4.开发action
在src下面创建struts的action，继承ActionSupport
//开发action： 处理请求
public class HelloAction extends ActionSupport { // 处理请求
public String execute() throws Exception {
System.out.println("访问到了action，正在处理请求");
System.out.println("调用service");
return "success";
}
}
5.在src下面添加struts.xml文件（可以在struts包中搜索）
一个struts.xml中可以有多个package，但是package的名称不能重复
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<!-- name任意名称，extends固定写法 -->
<package name="mystruts" extends="struts-default">
<!-- name：浏览器要访问的名称，class：编写的action全称，method：action下面的方法 -->
<action name="hello" class="com.eggtwo.action.HelloAction"
method="execute">
<!-- name:返回值， 跳转地址 -->
<result name="success">/index.jsp</result>
</action>
</package>
</struts>
5.1struts.xml的第二种配置方式：
在src下面添加总的struts.xml文件，然后在总文件中引用各个包中的struts.xml文件
总struts.xml文件：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<!-- 总配置文件：引用其他包中的独立的配置文件 -->
<include file="com/eggtwo/action/struts.xml"></include>
</struts>
包中的struts.xml文件：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<!-- name任意名称，extends:继承的类 -->
<package name=com.eggtwo.action namespace="/" extends="struts-default" abstract="false">
<!-- name：浏览器要访问的名称，class：编写的action全称，method：action下面的方法 -->
<action name="execute" class="com.eggtwo.action.HelloAction" method="execute">
<!-- name:返回值， 跳转地址 -->
<result name="success" >/index.jsp</result>
</action> <action name="login" class="com.eggtwo.action.LoginAction" method="login">
<!-- name:返回值， 跳转地址 -->
<result name="success" >/login.jsp</result>
</action>
</package>
</struts>
项目结构：
2.执行流程
服务器启动：
1. 加载项目web.xml
2. 创建Struts核心过滤器对象， 执行filter -> init()
struts-default.xml, 核心功能的初始化
struts-plugin.xml, struts相关插件
struts.xml 用户编写的配置文件
访问：
3. 用户访问Action, 服务器根据访问路径名称，找对应的aciton配置, 创建action对象
4. 执行默认拦截器栈中定义的18个拦截器
5. 执行action的业务处理方法
Hibernate
1.开发流程
项目配置好后的结构：
1.下载源码： 版本：hibernate-distribution-3.6.0.Final
2.引入hibernate需要的开发包（3.6版本），如果没有引用成功，在jar包上右键执行：add as library
3.编写实体对象及对象的映射xml文件
实体类：
package com.eggtwo.test;
import java.util.Date;
public class Student {
private int id;
private String name;
private int age;
private Date birthday;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
数据库表结构：
映射xml文件：（放在包下面）
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.eggtwo.test"> <class name="Student" table="student">
<!-- 主键 ，映射-->
<id name="id" column="id">
<generator class="native"/>
</id>
<!-- 非主键，映射 -->
<property name="name" column="name"></property>
<property name="age" column="age"></property>
<property name="birthday" column="birthday"></property>
</class> </hibernate-mapping>
4.配置主配置文件：src/hibernate.cfg.xml
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration>
<session-factory>
<!-- 数据库连接配置 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql:///test</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">123456</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property> <property name="hibernate.show_sql">true</property> <!-- 加载所有映射 -->
<mapping resource="com/eggtwo/test/Student.hbm.xml"/>
</session-factory>
</hibernate-configuration>
5.测试添加一条数据：
package com.eggtwo.test;
import java.util.Date; import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test; public class TestApp {
@Test
public void testHello() throws Exception {
// 创建对象：主键自增长
Student s = new Student();
s.setAge(12);
s.setName("班长");
s.setBirthday(new Date()); // 获取加载配置文件的管理类对象
Configuration config = new Configuration();
config.configure(); // 默认加载src/hibenrate.cfg.xml文件
// 创建session的工厂对象
SessionFactory sf = config.buildSessionFactory();
// 创建session (代表一个会话，与数据库连接的会话)
Session session = sf.openSession();
// 开启事务
Transaction tx = session.beginTransaction();
//保存-数据库
session.save(s);
// 提交事务
tx.commit();
System.out.println("save success");
// 关闭
session.close();
sf.close();
} }
2.映射详解
spring
ssh=struts(controller)+spring(service)+hibernate(dao)
1.spring简介
Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架。
且可以和其他框架一起使用；Spring与Struts, Spring与hibernate
(起到整合（粘合）作用的一个框架)
Spring提供了一站式解决方案：
1） Spring Core spring的核心功能： IOC容器, 解决对象创建及依赖关系
2） Spring Web Spring对web模块的支持。
-à 可以与struts整合,让struts的action创建交给spring
-à spring mvc模式
3） Spring DAO Spring 对jdbc操作的支持 【JdbcTemplate模板工具类】
4） Spring ORM spring对orm的支持：
à 既可以与hibernate整合，【session】
à 也可以使用spring的对hibernate操作的封装
5）Spring AOP 切面编程
6）SpringEE spring 对javaEE其他模块的支持
2.spring开发步骤
1.下载引用开发包
spring各个版本中：
在3.0以下的版本，源码有spring中相关的所有包【spring功能 + 依赖包】
如2.5版本；
在3.0以上的版本，源码中只有spring的核心功能包【没有依赖包】
(如果要用依赖包，需要单独下载！)
源码, jar文件：spring-framework-3.2.5.RELEASE
commons-logging-1.1.3.jar 日志
spring-beans-3.2.5.RELEASE.jar bean节点
spring-context-3.2.5.RELEASE.jar spring上下文节点
spring-core-3.2.5.RELEASE.jar spring核心功能
spring-expression-3.2.5.RELEASE.jar spring表达式相关表
以上是必须引入的5个jar文件！
2.在src下面的包中创建Student对象：
package com.eggtwo.test;
public class Student {
private int age;
private String name;
public Student(){
super();
System.out.println("调用了student的构造函数");
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void init_student()
{
System.out.println("初始化了对象");
}
public void destroy_student()
{
System.out.println("销毁了对象");
}
}
3.在src下面的包中引入核心配置文件： applicationContext.xml
<?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: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/context
http://www.springframework.org/schema/context/spring-context.xsd"> <!--
1) 对象创建： 单例/多例
scope="singleton", 默认值， 即 默认是单例 【service/dao/工具类】
scope="prototype", 多例； 【Action对象】
2) 什么时候创建?
scope="prototype" 在用到对象的时候，才创建对象。
scope="singleton" 在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。
3)是否延迟创建
lazy-init="false" 默认为false, 不延迟创建，即在启动时候就创建对象
lazy-init="true" 延迟初始化， 在用到对象的时候才创建对象（只对单例有效）
4) 创建对象之后，初始化/销毁
init-method="init_student" 【对应对象的init_student方法，在对象创建爱之后执行 】
destroy-method="destroy_student" 【在调用容器对象的destriy方法时候执行，(容器用实现类)】 -->
<bean id="student" class="com.eggtwo.test.Student" scope="prototype" lazy-init="false" init-method="init_student" destroy-method="destroy_student"></bean> </beans>
4.使用pring创建对象：getBean中的参数是xml中设置的id
package com.eggtwo.test; import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext; public class APPTest {
@Test
public void test(){
// 得到IOC容器对象 【用实现类，因为要调用销毁的方法】
System.out.println("-----容器创建前-----");
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("com/eggtwo/test/applicationContext.xml");
System.out.println("-----容器创建完成-----"); // 从容器中获取bean
Student student1 = (Student) ac.getBean("student");
Student student2 = (Student) ac.getBean("student"); System.out.println(student1);
System.out.println(student2); // 销毁容器对象
ac.destroy();
}
}
2.spring IOC容器的配置
1.对象的创建方式
SpringIOC容器，是spring核心内容。
作用： 创建对象 & 处理对象的依赖关系
IOC容器创建对象：
创建对象, 有几种方式：
1） 调用无参数构造器
2） 带参数构造器
3） 工厂创建对象
工厂类，静态方法创建对象
工厂类，非静态方法创建对象
<!-- ###############对象创建############### -->
<!-- 1. 默认无参数构造器
<bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
-->
<!-- 2. 带参数构造器 -->
<bean id="user2" class="cn.itcast.b_create_obj.User">
<constructor-arg index="0" type="int" value="100"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
</bean>
<!-- 定义一个字符串，值是"Jack" ; String s = new String("jack")-->
<bean id="str" class="java.lang.String">
<constructor-arg value="Jacks"></constructor-arg>
</bean>
<bean id="user3" class="cn.itcast.b_create_obj.User">
<constructor-arg index="0" type="int" value="100"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
</bean>
<!-- 3. 工厂类创建对象 -->
<!-- # 3.1 工厂类，实例方法 -->
<!-- 先创建工厂 -->
<bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
<!-- 在创建user对象，用factory方的实例方法 -->
<bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
<!-- # 3.2 工厂类： 静态方法 -->
<!--
class 指定的就是工厂类型
factory-method 一定是工厂里面的“静态方法”
-->
<bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
2.对象的依赖关系
Spring中，如何给对象的属性赋值? 【DI, 依赖注入】
1) 通过构造函数
2) 通过set方法给属性注入值
3) p名称空间
4)自动装配(了解)
5) 注解
<bean id="userDao" class="com.eggtwo.dao.UserDao" ></bean>
<bean id="userService" class="com.eggtwo.service.UserService">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userAction" class="com.eggtwo.action.UserAction">
<property name="userService" ref="userService"></property>
</bean>
3.spring和strut结合
步骤：
引入jar文件
1）引入struts .jar相关文件
2）spring-core 相关jar文件
3）spring-web 支持jar包
spring-web-3.2.5.RELEASE.jar 【Spring源码】
struts2-spring-plugin-2.3.4.1.jar 【Struts源码】
配置:
4）配置XML
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0"> <!-- 引入struts核心过滤器 -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping> <!-- 2. spring 配置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/classes/bean-*.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener> </web-app>
bean.xml 【spring ioc容器配置】
每个包配置一个bean
<?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: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/context
http://www.springframework.org/schema/context/spring-context.xsd"> <bean id="userService" class="com.eggtwo.service.UserService">
<property name="userDao" ref="userDao"></property>
</bean> </beans>
struts.xml struts路径与action映射配置】
注意：action交给了spring创建，不再是tomcat创建
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<!-- name任意名称，extends:继承的类 -->
<package name="com.eggtwo.action" namespace="/" extends="struts-default" abstract="false"> <action name="execute" class="userAction" method="execute">
<!-- name:返回值， 跳转地址 -->
<result name="success" >/index.jsp</result>
</action> </package>
</struts>
【核心过滤器： 引入struts功能】
【初始化spring的ioc容器】
4.代理模式
静态代理（JDK代理）
动态代理（JDK代理）
CgLib代理
5.Spring 注解实现AOP编程
AOP的实现本质上是代理（动态代理和Cglib代理）
注意：java jdk使用1.8版本，spring的jar包要使用4.2版本以上才可以使用AOP功能
开发步骤：
1.引入aop相关jar包
spring-aop-3.2.5.RELEASE.jar [spring3.2.5源码/libs]
aopalliance.jar [spring-framework-2.5.6/lib/aopalliance]
aspectjrt.jar [aspectj-1.8.2/lib]
aspectjweaver.jar [aspectj-1.8.2/lib]
2.bean.xml中引入aop名称空间
3.在bean.xml中开启AOP注解模式
4.新建切面类
package com.eggtwo.aopanno; import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component; @Component //注解 ioc
@Aspect //指定当前类为切面类
public class MyAspect { @Pointcut("execution(* com.eggtwo.aopanno.UserDao.*(..))")
public void myPointcut() {
} //执行方法前执行
@Before("myPointcut()")
public void begin() {
System.out.println("开始执行");
} //执行目标方法后执行：（无论目标方法是否出现异常，都会执行）
@After("myPointcut()")
public void end() {
System.out.println("结束执行");
} //执行目标方法后执行：（发生异常不执行）
@AfterReturning("myPointcut()")
public void afterReturning() {
System.out.println("afterReturning");
} //执行目标方法后执行：（发生异常执行）
@AfterThrowing("myPointcut()")
public void afterThrowing() {
System.out.println("afterThrowing");
}
//环绕通知：环绕目标方法执行
@Around("myPointcut()")
public void around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("环绕前");
pjp.proceed();
System.out.println("环绕后"); }
}
执行结果顺序：
5.测试
package com.eggtwo.aopanno; import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestApp {
@Test
public void test() {
ApplicationContext ac = new ClassPathXmlApplicationContext("com/eggtwo/aopanno/bean.xml");
UserDao userDao = (UserDao) ac.getBean("userDao");
System.out.println(userDao.getClass());
userDao.save();
}
}
6.Spring XML实现AOP编程
1.引入jar相关开发包（同步骤5.1）
2.引入命名空间（同5.2）
3.aop配置：添加切面类
package com.eggtwo.aopxml; import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component; public class MyAspect { //执行方法前执行
public void begin() {
System.out.println("开始执行");
} //执行目标方法后执行：（无论目标方法是否出现异常，都会执行）
public void end() {
System.out.println("结束执行");
} //执行目标方法后执行：（发生异常不执行）
public void afterReturning() {
System.out.println("afterReturning");
} //执行目标方法后执行：（发生异常执行）
public void afterThrowing() {
System.out.println("afterThrowing");
} //环绕通知：环绕目标方法执行
public void around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("环绕前");
pjp.proceed();
System.out.println("环绕后"); }
}
4.配置bean.xml
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
">
<!--spring IOC-->
<bean id="userDao" class="com.eggtwo.aopxml.UserDao"></bean>
<bean id="myAspect" class="com.eggtwo.aopxml.MyAspect"></bean> <!--AOP配置-->
<aop:config>
<!-- 定义切面点表达式：指定拦截的方法 -->
<aop:pointcut id="myPointcut" expression="execution(* com.eggtwo.aopxml.UserDao.*(..))"/>
<!-- 切面：引用上面配置的切面类-->
<aop:aspect ref="myAspect">
<!--<aop:before method="begin" pointcut="execution(* com.eggtwo.aopxml.UserDao.*(..))"/>-->
<aop:before method="begin" pointcut-ref="myPointcut"/>
<aop:before method="end" pointcut-ref="myPointcut"/>
</aop:aspect>
</aop:config>
</beans>
7.Spring 切入点表达式
作用：指定拦截的方法
8.Spring 事务管理
事务的实现本身是AOP
XML方式实现spring声明式事务
SSH整合
1.引入jar包
Struts 核心jar
Hibernate 核心jar
Spring
Core 核心功能
Web 对web模块支持
Aop aop支持
Orm 对hibernate支持
Jdbc/tx jdbc支持包、事务相关包
2.配置xml
*.hbm.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.eggtwo.entity"> <class name="Student" table="t_student">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<!-- 外键映射：多对一 -->
<many-to-one name="grade" column="gradeId" class="Grade"></many-to-one>
<property name="name"></property>
<property name="age"></property>
<property name="birthday"></property> </class> </hibernate-mapping>
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0"> <!-- 配置spring的OpenSessionInView模式 【目的：JSp页面访问懒加载数据】 -->
<!-- 注意：访问struts时候需要带上*.action后缀，这样才能访问懒加载数据 -->
<filter>
<filter-name>OpenSessionInView</filter-name>
<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>OpenSessionInView</filter-name> <!--url请求设置-->
<url-pattern>*.action</url-pattern>
</filter-mapping> <!-- struts2配置 -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping> <!-- Spring配置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:bean*.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener> <welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
bean.xml
每一个包中单独一个bean
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 所有配置的公共部分 -->
<!-- 1) 数据源对象: C3P0连接池实例 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///test"></property>
<property name="user" value="root"></property>
<property name="password" value="123456"></property>
<property name="initialPoolSize" value="3"></property>
<property name="maxPoolSize" value="6"></property>
</bean> <!-- 2) SessionFactory实例创建 -->
<!-- 所有的配置都由spring维护(项目中不需要hibernate.cfg.xml啦) -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- a. 连接池 -->
<property name="dataSource" ref="dataSource"></property>
<!-- b. hibernate常用配置： 方言、显示sql、自动建表等 -->
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!-- c. 映射配置 -->
<property name="mappingLocations">
<list>
<value>classpath:com/eggtwo/entity/*.hbm.xml</value>
</list>
</property>
</bean> <!-- 3) 事务配置 -->
<!-- # 事务管理器 -->
<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!-- # 事务增强 -->
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="*" read-only="false"/>
</tx:attributes>
</tx:advice>
<!-- # AOP配置 -->
<aop:config>
<aop:pointcut expression="execution(* com.eggtwo.service.*.*(..))" id="pt"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
</aop:config> </beans>
struts.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache.org/dtds/struts-2.3.dtd"> <struts> <package name="myAction" extends="struts-default">
<!-- action实例交给spring容器创建 -->
<!--注意：action的class不能写全称类，要写bean-action中的 bean id-->
<!-- 这种写法是把action交给tomcat创建，所以类要写全称
<action name="show" class="com.eggtwo.action.StudentAction" method="execute">
<result name="success">/index.jsp</result>
</action>
-->
<action name="show" class="studentAction" method="execute">
<result name="success">/index.jsp</result>
</action> </package> </struts>
3.开发
Entity/Dao/service/action
Entity
package com.eggtwo.entity;
import java.util.Date;
public class Student {
private int id;
// private int gradeId;
private String name;
private int age;
private Date birthday;
private boolean isMan;
public Grade getGrade() {
return grade;
}
public void setGrade(Grade grade) {
this.grade = grade;
}
private Grade grade;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
// public int getGradeId() {
// return gradeId;
// }
//
// public void setGradeId(int gradeId) {
// this.gradeId = gradeId;
// }
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public boolean isMan() {
return isMan;
}
public void setMan(boolean man) {
isMan = man;
}
}
entity实体对象
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.eggtwo.entity"> <class name="Student" table="t_student">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<!-- 外键映射：多对一 -->
<many-to-one name="grade" column="gradeId" class="Grade"></many-to-one>
<property name="name"></property>
<property name="age"></property>
<property name="birthday"></property> </class> </hibernate-mapping>
entity实体对象映射数据库XML文件
Dao
package com.eggtwo.dao; import com.eggtwo.entity.Student;
import org.hibernate.SessionFactory;
import org.hibernate.classic.Session;
import org.springframework.orm.hibernate4.HibernateTemplate; import java.io.Serializable;
import java.util.List; public class StudentDao {
private SessionFactory sessionFactory; public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
public void save(Student student){
//HibernateTemplate hibernateTemplate=new HibernateTemplate(sessionFactory);
sessionFactory.getCurrentSession().save(student);
}
public Student findById(Serializable id){
Student o = (Student) sessionFactory.getCurrentSession().get(Student.class, id);
return o;
}
// public List<Student> findList(){
// Session currentSession = sessionFactory.getCurrentSession();
// currentSession.find()
// }
}
数据访问
Service：事务处理在此包中
package com.eggtwo.service; import com.eggtwo.dao.StudentDao;
import com.eggtwo.entity.Student; import java.io.Serializable; public class StudentService {
private StudentDao studentDao; public void setStudentDao(StudentDao studentDao) {
this.studentDao = studentDao;
}
public void save(Student student){
studentDao.save(student);
}
public Student findById(Serializable id){
return studentDao.findById(id);
}
}
服务
action
package com.eggtwo.action; import com.eggtwo.entity.Student;
import com.eggtwo.service.StudentService;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import org.omg.PortableServer.REQUEST_PROCESSING_POLICY_ID; import java.util.Map; public class StudentAction extends ActionSupport {
//IOC注入
private StudentService studentService; public void setStudentService(StudentService studentService) {
this.studentService = studentService;
} @Override
public String execute() throws Exception {
int studentId = 2;
Student student = studentService.findById(studentId);
Map<String, Object> request = (Map<String, Object>) ActionContext.getContext().get("request");
request.put("student", student);
return SUCCESS;
}
}
action
spring mvc
ssm=spring mvc+spring +mybatis
spring mvc工作流程
1A）客户端发出http请求，只要请求形式符合web.xml文件中配置的*.action的话，就由DispatcherServlet来处理。
1B）DispatcherServlet再将http请求委托给映射器的对象来将http请求交给对应的Action来处理
2）映射器根据客户的http请求，再对比<bean name="/hello.action如果匹配正确，再将http请求交给程序员写的Action
3）执行Action中的业务方法，最终返回一个名叫ModelAndView的对象，其中封装了向视图发送的数据和视图的逻辑名
4）ModelAndView对象随着响应到到DispatcherServlet中了
5）这时DispatcherServlet收到了ModelAndView对象，它也不知道视图逻辑名是何意，又得委托一个名叫视图解析器的对象去具体解析ModelAndView对象中的内容
6）将视图解析器解析后的内容，再次交由DispatcherServlet核心控制器，这时核心控制器再将请求转发到具体的视图页面，取出数据，再显示给用户
XML实现spring mvc
开发步骤：
注意：使用的spring framework版本是：4.2.5
1.引入jar包：
spring核心包
commons-logging-1.1.3.jar
spring-beans-4.2.5.RELEASE.jar
spring-context-4.2.5.RELEASE.jar
spring-core-4.2.5.RELEASE.jar
spring-expression-4.2.5.RELEASE.jar
spring mvc包
spring-web-4.2.5.RELEASE.jar
spring-webmvc-4.2.5.RELEASE.jar
2.xml配置
web.xml配置
配置spring mvc核心控制器
解决提交表单中文乱码
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0"> <!-- 注册springmvc核心控制器-->
<servlet>
<!--servlet-name的值对应一个文件：/WEB-INF/DispatcherServlet-servlet.xml -->
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<!-- 指定application.xml文件 -->
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping> <!--spring编码过滤器：解决POST提交中文乱码问题-->
<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>
springmvc.xml配置
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/tx/spring-mvc.xsd "> <!-- 1.注册Action(必须配置) -->
<bean name="/hello.action" class="com.eggtwo.action.HelloController"></bean> <!--2.映射器：如果将bean标签的name属性值作为请求URL.此标签可以省略-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean> <!--3.适配器：实现了Controller接口的适配器，默认可省略-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean> <!--4.视图解析器-->
<!--
如果Action中书写的是视图逻辑名称，那么视图解析器就必须配置
如果Action中书写的是视图真实名称，那么视图解析器就不能配置
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 路径前缀 -->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!-- 路径后缀 -->
<property name="suffix" value=".jsp"/>
<!-- 前缀+视图逻辑名+后缀=真实路径 -->
</bean>
</beans>
3.编写Action
package com.eggtwo.action; import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.annotation.Annotation; public class HelloController implements Controller {
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("message", "这是我的第二个springmvc应用程序，视图使用逻辑名"); //原来封装视图的真实路径
// modelAndView.setViewName("/WEB-INF/jsp/success.jsp"); String name = request.getParameter("name");//获取表单提交的数据
System.out.println("姓名:"+name); //现在封装视图的逻辑名称
modelAndView.setViewName("success"); return modelAndView;
} }
注解实现spring mvc
解决的问题：
1.一个controller中放置多个action
2.获取get/post请求的参数(action接收的string类型的date参数怎么转成date)
3.限定action只能接收一种请求方式（get/post）
4.解决表单提交的中文乱码
5.在action中获取request/response
6.在action中重定向
7.action返回值类型（返回html、string、json、file等等）
8.在action中获取request
1.引入jar包：
spring核心包
commons-logging-1.1.3.jar
spring-beans-4.2.5.RELEASE.jar
spring-context-4.2.5.RELEASE.jar
spring-core-4.2.5.RELEASE.jar
spring-expression-4.2.5.RELEASE.jar
spring aop包(注解会使用到aop)
aopalliance.jar
aspectjrt.jar
aspectjweaver.jar
spring-aop-4.2.5.RELEASE.jar
spring mvc包
spring-web-4.2.5.RELEASE.jar
spring-webmvc-4.2.5.RELEASE.jar
2.配置XML：
web.xml配置
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0"> <!-- 注册springmvc核心控制器-->
<servlet>
<!--servlet-name的值对应一个文件：/WEB-INF/DispatcherServlet-servlet.xml -->
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<!-- 指定application.xml文件 -->
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring_annotation.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping> <!--spring编码过滤器：解决POST提交中文乱码问题-->
<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>
spring mvc xml配置
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/tx/spring-mvc.xsd ">
<!--让spring ioc去扫描具体包下的所有具有注解@Controller的类-->
<context:component-scan base-package="com.eggtwo.action"></context:component-scan> <!--注解映射器：可省略-->
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"></bean> <!--视图解析器-->
<!--
如果Action中书写的是视图逻辑名称，那么视图解析器就必须配置
如果Action中书写的是视图真实名称，那么视图解析器就不能配置
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 路径前缀 -->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!-- 路径后缀 -->
<property name="suffix" value=".jsp"/>
<!-- 前缀+视图逻辑名+后缀=真实路径 -->
</bean>
</beans>
3.开发controller 和action：
package com.eggtwo.action; import com.eggtwo.entity.Student;
import com.sun.org.apache.regexp.internal.RE;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.ServletRequestDataBinder;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.context.request.WebRequest; import javax.servlet.http.HttpServletRequest;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date; /**
* 此控制器是单例模式，构造函数只执行一次
* 注解控制器
*/
@Controller
@RequestMapping(value = "/anno")
public class AnnotationController { public AnnotationController() {
System.out.println("AnnotationController()");
} @RequestMapping(value = "/login.action")
public String login(Model model) {
model.addAttribute("message", "第一个注解实现的spring mvc login");
return "success";//逻辑名称，需要配置视图解析器
//return "/WEB-INF/jsp/success.jsp"; } /**
* 设置请求的url,接收参数的方式，请求的方式（get/post）(默认get/post请求都支持)
*/
@RequestMapping(value = "/register1.action", method = {RequestMethod.POST, RequestMethod.GET})
public String register1(Model model, String name, int age, boolean man) { model.addAttribute("message", "注册成功");
return "success";
// return "/WEB-INF/jsp/success.jsp"; } /**
* 请求url中的.action可以省略
*/
@RequestMapping(value = "/register", method = RequestMethod.POST)
public String register(Model model, Student student) {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); System.out.println(student.getBirthday());
model.addAttribute("message", "注册成功");
model.addAttribute("student", student); return "success";
// return "/WEB-INF/jsp/success.jsp"; } /**
* 日期类型转换器
*
* @param binder
*/
@InitBinder
public void initBinder(WebDataBinder binder) {
//设置什么类型的时间格式可以转
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
dateFormat.setLenient(false);
binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));//true:允许为空, false:不允许为空
}
}
3.1action向view视图(jsp页面传值)
@RequestMapping(value = "/register", method = RequestMethod.POST)
public String register(Model model, Student student) {
model.addAttribute("message", "注册成功");
model.addAttribute("student", student);
return "success"; }
3.2指定action加载返回的视图（jsp页面）
指定物理视图名称：
return "/WEB-INF/jsp/success.jsp";
指定逻辑视图名称：
return "success";
逻辑视图需要在spring mvc文件配置视图解析器
<!--视图解析器-->
<!--
如果Action中书写的是视图逻辑名称，那么视图解析器就必须配置
如果Action中书写的是视图真实名称，那么视图解析器就不能配置
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 路径前缀 -->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!-- 路径后缀 -->
<property name="suffix" value=".jsp"/>
<!-- 前缀+视图逻辑名+后缀=真实路径 -->
</bean>
4.URL配置：
在controller和请求action上配置
@RequestMapping(value = "/anno")
5.请求方式配置：
@RequestMapping(value = "/register1.action", method = {RequestMethod.POST, RequestMethod.GET})
@RequestMapping(value = "/register", method = RequestMethod.POST)
如果不配置method，默认支持所有请求方式
6.请求参数接收：
1.变量直接接收：方法的变量名要和表单的name值保持一致，多用于get查询请求
@RequestMapping(value = "/register1.action", method = {RequestMethod.POST, RequestMethod.GET})
public String register1(Model model, String name, int age, boolean man) {
model.addAttribute("message", "注册成功");
return "success";
// return "/WEB-INF/jsp/success.jsp";
}
2.模型绑定接收：方法的变量名要和表单的name值保持一致，可以设置多个模型，多用于表单提交
@RequestMapping(value = "/register", method = RequestMethod.POST)
public String register(Model model, Student student) {
System.out.println(student.getBirthday());
model.addAttribute("message", "注册成功");
model.addAttribute("student", student); return "success";
// return "/WEB-INF/jsp/success.jsp"; }
3.数组参数接收：批量删除时用于接收ids，批量添加
ids为checkbox的名称
@RequestMapping(value = "/batchDelete.action")
public String register(Model model, Integer[] ids) {
for(int id :ids){
System.out.println(id);
}
return "success"; }
4.接收List<javaBean>集合
7.内部转发和重定向
内部 转发，url不变：可以使用model在多个action中传值，因为model是request域对象
@RequestMapping(value = "/forward.action")
public String forward(Model model) {
return "forward:/anno/login.action";
}
URL重定向，以url后缀的方式进行传值
@RequestMapping(value = "/go.action")
public String go(Model model) {
return "redirect:/anno/login.action?id=3";
}
8.action返回json和字符串
第一步：导入json包
jackson-annotations-2.6.0-xh.jar
jackson-core-2.6.0-xh.jar
jackson-databind-2.6.0-xh.jar
jackson-jr-all-2.4.3-xh.jar
第二步：在action请求方法上使用@ResponseBody注解表示该方法的返回值放在响应体（Response Body）返回给用户
第三步：在springmvc xml文件中配置json解析适配器
<!-- 注册json解析适配器 -->
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
</list>
</property>
</bean>
第四步：开发action
返回json
@RequestMapping(value = "/getJson.action")
@ResponseBody
public Student getJson() {
Student student = new Student();
student.setName("测试");
student.setMan(true);
student.setBirthday(new Date());
student.setAge(14);
student.setScore(12.254);
return student;
}
返回字符串
@RequestMapping(value = "/getString.action",method = RequestMethod.GET)
@ResponseBody
public String getString() {
return "直接返回字符串";
}
9.在action中获取当前请求的request
在controller中添加如下特性：可以放在baseController
@Autowired
protected HttpServletRequest request; //自动注入request
mybatis
一、 入门开发步骤
1.导入相关jar包
mybatis3.4.2核心开发包
asm-5.1.jar
cglib-3.2.4.jar
commons-logging-1.1.3.jar
log4j-1.2.17.jar
mybatis-3.4.2.jar
mysql驱动包
mysql-connector-java-5.1.7-bin.jar
2.定义实体及实体映射文件
定义member实体
package com.eggtwo.entity; import java.math.BigDecimal;
import java.util.Date; public class Member {
private int id; public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} private String name;
private int age;
private Date birthday;
private boolean man;
private BigDecimal score; public BigDecimal getScore() {
return score;
} public void setScore(BigDecimal score) {
this.score = score;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} public Date getBirthday() {
return birthday;
} public void setBirthday(Date birthday) {
this.birthday = birthday;
} public boolean isMan() {
return man;
} public void setMan(boolean man) {
this.man = man;
}
}
定义MemberMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--映射文件命名空间：要唯一-->
<mapper namespace="memberDao">
<!--
*******当实体属性和表字段名称一致的话resultMap标签可以省略********
resultMap标签：映射实体和表关系
id:映射关系id,要唯一
type:实体全路径
-->
<resultMap id="memberMap" type="com.eggtwo.entity.Member">
<!--id：映射主键属性
result:映射非主键属性
property:实体属性名称
column:表字段名称
-->
<id property="id" column="id"/>
<result property="name" column="name"/>
<result property="age" column="age"/>
<result property="birthday" column="birthday"/>
<result property="man" column="man"/>
<result property="score" column="score"/>
</resultMap> <insert id="add" parameterType="com.eggtwo.entity.Member" useGeneratedKeys="true" keyProperty="id">
insert into t_member(name,age,birthday,man,score)
values(#{name},#{age},#{birthday},#{man},#{score})
</insert> <update id="update" parameterType="com.eggtwo.entity.Member">
update t_member set
name = #{name},
age = #{age},
birthday = #{birthday},
man = #{man},
score = #{score}
where id = #{id}
</update> <delete id="delete" parameterType="int">
delete from t_member where id = #{id}
</delete> <!-- <select id="getById" parameterType="int" resultType="com.eggtwo.entity.Member">-->
<!--resultType使用mybatis.xml中设置的别名，这样可以简化难度-->
<select id="getById" parameterType="int" resultType="memberEntity">
select id,name,age,birthday,man,score
from t_member
where id=#{id}
</select>
<!--
理论上resultType的值应该是:List<com.eggtwo.entity.Member>
实际上只需要写List集合中的类型就可以
-->
<select id="getAll" resultType="com.eggtwo.entity.Member">
select *
from t_member
</select>
<!--分页：多参数的写法-->
<select id="getPageList" parameterType="map" resultType="com.eggtwo.entity.Member">
select id,name,age,birthday,man,score
from t_member limit #{start},#{size}
</select>
</mapper>
3.定义mybatis.cfg.xml文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 加载类路径下的属性文件 -->
<!--加载数据库连接配置信息-->
<properties resource="jdbc.properties"/>
<!-- 设置类型别名 -->
<typeAliases>
<!--设置实体类Member的别名：memberEntity-->
<typeAlias type="com.eggtwo.entity.Member" alias="memberEntity"/>
</typeAliases> <!-- 设置一个默认的连接环境信息 -->
<environments default="mysql_developer"> <!-- 连接环境信息，取一个任意唯一的名字 -->
<environment id="mysql_developer">
<!-- mybatis使用jdbc事务管理方式 -->
<transactionManager type="jdbc"/>
<!-- mybatis使用连接池方式来获取连接 -->
<dataSource type="pooled">
<!--配置与数据库交互的4个必要属性 -->
<!-- 直接配置方式，不推荐-->
<!--<property name="driver" value="com.mysql.jdbc.Driver"/>-->
<!-- <property name="url" value="jdbc:mysql://127.0.0.1:3306/test"/>-->
<!--<property name="username" value="root"/>-->
<!-- <property name="password" value="123456"/>--> <!--直接在jdbc.properties文件中配置连接-->
<property name="driver" value="${mysql.driver}"/>
<property name="url" value="${mysql.url}"/>
<property name="username" value="${mysql.username}"/>
<property name="password" value="${mysql.password}"/> </dataSource>
</environment> </environments> <!-- 加载映射文件-->
<mappers>
<mapper resource="com/eggtwo/entity/MemberMapper.xml"/>
</mappers>
</configuration>
mybatis.cfg.xml加载的jdbc.properties文件
mysql.driver=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql://127.0.0.1:3306/test
mysql.username=root
mysql.password=123456
4.定义mybatis帮助类：MybatisUtil
package com.eggtwo.dao; import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder; import java.io.IOException;
import java.io.Reader;
import java.sql.Connection; public class MybatisUtil { private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();
private static SqlSessionFactory sqlSessionFactory;
/**
* 加载位于src/mybatis.xml配置文件
*/
static{
try {
Reader reader = Resources.getResourceAsReader("mybatis.cfg.xml");
sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
/**
* 禁止外界通过new方法创建
*/
private MybatisUtil(){}
/**
* 获取SqlSession
*/
public static SqlSession getSqlSession(){
//从当前线程中获取SqlSession对象
SqlSession sqlSession = threadLocal.get();
//如果SqlSession对象为空
if(sqlSession == null){
//在SqlSessionFactory非空的情况下，获取SqlSession对象
sqlSession = sqlSessionFactory.openSession();
//将SqlSession对象与当前线程绑定在一起
threadLocal.set(sqlSession);
}
//返回SqlSession对象
return sqlSession;
}
/**
* 关闭SqlSession与当前线程分开
*/
public static void closeSqlSession(){
//从当前线程中获取SqlSession对象
SqlSession sqlSession = threadLocal.get();
//如果SqlSession对象非空
if(sqlSession != null){
//关闭SqlSession对象
sqlSession.close();
//分开当前线程与SqlSession对象的关系，目的是让GC尽早回收
threadLocal.remove();
}
} }
5.定义MemberDao测试mybatis增删查改
6.测试
public static void main(String[] args) throws Exception {
Connection conn = MybatisUtil.getSqlSession().getConnection();
System.out.println(conn != null ? "连接成功" : "连接失败");
MemberDao memberDao = new MemberDao();
Member member = new Member();
member.setId(2);
member.setAge(14);
member.setName("张三1");
member.setBirthday(new Date());
member.setMan(true);
member.setScore(new BigDecimal(123.24));
memberDao.add(member);
// memberDao.update(member);
// memberDao.delete(3);
Member member1 = memberDao.getById(2);
System.out.println(member1.getName());
List<Member> memberList = memberDao.getPageList(2,2);
System.out.println("size:"+memberList.size());
for (Member m : memberList){
System.out.println(m.getId());
}
}
二、 动态SQL
1.多条件查询
mapper.xml配置
<select id="getListByWhere" parameterType="map" resultType="com.eggtwo.entity.Member">
select id,name,age,birthday,man,score
from t_member
<where>
<if test="name!=null and name!=''">
and name like #{name}
</if>
<if test="score!=null">
and score > #{score}
</if>
</where>
</select>
dao调用
public List<Member> getListByWhere(String name,BigDecimal score) throws Exception {
SqlSession sqlSession = null;
try {
sqlSession = MybatisUtil.getSqlSession();
Map<String,Object> map=new LinkedHashMap<>();
map.put("name",name==null?null: "%"+name+"%");//做like查询
map.put("score",score);
List<Member> memberList= sqlSession.selectList("memberDao.getListByWhere",map);
return memberList;
} catch (Exception e) {
e.printStackTrace();
} finally {
//关闭连接
MybatisUtil.closeSqlSession();
}
return null;
}
测试：
List<Member> memberList = memberDao.getListByWhere("3",new BigDecimal(30));
2.部分更新字段
mapper.xml配置
<update id="dynamicUpdate" parameterType="map">
update t_member
<set>
<if test="name!=null">
name = #{name},
</if>
<if test="age!=null">
age = #{age},
</if>
<if test="birthday!=null">
birthday = #{birthday},
</if>
<if test="man!=null">
man = #{man},
</if>
<if test="score!=null">
score = #{score},
</if>
</set>
where id=#{id}
</update>
dao调用：
public void dynamicUpdate(int id, String name,Integer age,Date birthday,Boolean man,BigDecimal score) throws Exception {
SqlSession sqlSession = null;
try {
sqlSession = MybatisUtil.getSqlSession();
Map<String,Object> map=new LinkedHashMap<>();
map.put("id",id);
map.put("name",name);
map.put("age",age);
map.put("birthday",birthday);
map.put("man",man);
map.put("score",score);
sqlSession.update("memberDao.dynamicUpdate", map);
//提交事务
sqlSession.commit();
} catch (Exception e) {
e.printStackTrace();
//事务回滚
sqlSession.rollback();
} finally {
//关闭连接
MybatisUtil.closeSqlSession();
}
}
测试：
memberDao.dynamicUpdate(2,"jack",null,null,false,null);
3.根据id集合或数组不确定删除：delete from table where id in(id1,id2,id3,……)
mapper.xml配置
<!--根据ids数组批量删除数据-->
<delete id="batchDelete" >
delete from t_member where id in
<!--
循环数组
解析成：(1,2,34)
#id表示数组中的每一个元素，名称可以任意写
-->
<foreach collection="array" open="(" close=")" separator="," item="id">
#{id}
</foreach>
</delete>
<!--根据ids列表批量删除数据-->
<delete id="batchDeleteList" >
delete from t_member where id in
<!--
循环数组
解析成：(1,2,34)
#id表示数组中的每一个元素，名称可以任意写
-->
<foreach collection="list" open="(" close=")" separator="," item="id">
#{id}
</foreach>
</delete>
dao调用：
public void batchDelete(int[] ids) throws Exception {
SqlSession sqlSession = null;
try {
sqlSession = MybatisUtil.getSqlSession();
sqlSession.update("memberDao.batchDelete", ids);
sqlSession.commit();
} catch (Exception e) {
e.printStackTrace();
//事务回滚
sqlSession.rollback();
} finally {
//关闭连接
MybatisUtil.closeSqlSession();
}
}
public void batchDeleteList(List<Integer> ids) throws Exception {
SqlSession sqlSession = null;
try {
sqlSession = MybatisUtil.getSqlSession();
sqlSession.update("memberDao.batchDeleteList", ids);
sqlSession.commit();
} catch (Exception e) {
e.printStackTrace();
//事务回滚
sqlSession.rollback();
} finally {
//关闭连接
MybatisUtil.closeSqlSession();
}
}
测试：
memberDao.batchDelete(new int[]{1,4,5});
List<Integer> list=new ArrayList<>() ;
list.add(1);
list.add(17);
list.add(18);
memberDao.batchDeleteList(list);
4.动态插入部分字段
这个不常用
三、 多表查询
1.一对一映射
班级包t_grade和学生表t_student表
获取学生信息时同时把学生对应的班级信息获取出来
第一步：创建实体
Grade实体
package com.eggtwo.entity;
import java.util.List;
public class Grade {
private Integer id;
private String gradeName;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getGradeName() {
return gradeName;
}
public void setGradeName(String gradeName) {
this.gradeName = gradeName;
}
}
Grade
Student实体
package com.eggtwo.entity;
import java.util.Date;
public class Student {
private Integer id;
private String name;
private Integer age;
private Date birthday;
private Boolean man;
private Grade grade;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public Boolean getMan() {
return man;
}
public void setMan(Boolean man) {
this.man = man;
}
public Grade getGrade() {
return grade;
}
public void setGrade(Grade grade) {
this.grade = grade;
}
}
com.eggtwo.entity.Student
第二步：建立mapper.xml
GradeMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--映射文件命名空间：要唯一-->
<mapper namespace="gradeDao">
<!--
*******当实体属性和表字段名称一致的话resultMap标签可以省略********
resultMap标签：映射实体和表关系
id:映射关系id,要唯一
type:实体全路径
-->
<resultMap id="gradeMap" type="com.eggtwo.entity.Grade">
<!--id：映射主键属性
result:映射非主键属性
property:实体属性名称
column:表字段名称
-->
<id property="id" column="id"/>
<result property="gradeName" column="gradeName"/>
</resultMap>
</mapper>
StudentMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--映射文件命名空间：要唯一-->
<mapper namespace="studentDao">
<resultMap id="studentMap" type="com.eggtwo.entity.Student">
<id property="id" column="id"/>
<result property="name" column="name"/>
<result property="age" column="age"/>
<result property="birthday" column="birthday"/>
<result property="man" column="man"/>
<!--引用GradeMapper.xml中的resultMap，不需要再写一遍映射-->
<association property="grade" resultMap="gradeDao.gradeMap"/>
</resultMap> <!--返回值类型用resultMap代替resultType，可以解决实体字段类型和表字段类型不一致的问题-->
<select id="getById" parameterType="int" resultMap="studentMap">
select s.id,s.name,s.age,s.birthday,s.man,g.id,g.gradeName
from t_student s, t_grade g
where s.gradeId=g.id
and s.id=#{id}
</select> </mapper>
第三步：将mapper.xml加入到mybatis.cfg.xml文件中
<mappers>
<mapper resource="com/eggtwo/entity/StudentMapper.xml"/>
<mapper resource="com/eggtwo/entity/GradeMapper.xml"/>
</mappers>
第四步：编写StudentDao
package com.eggtwo.dao; import com.eggtwo.entity.Member;
import com.eggtwo.entity.Student;
import org.apache.ibatis.session.SqlSession; import java.math.BigDecimal;
import java.sql.Connection;
import java.util.*; public class StudentDao {
public Student getById(int id) throws Exception {
SqlSession sqlSession = null;
Student student = null;
try {
sqlSession = MybatisUtil.getSqlSession();
student = sqlSession.selectOne("studentDao.getById", id); } catch (Exception e) {
e.printStackTrace(); } finally {
//关闭连接
MybatisUtil.closeSqlSession();
}
return student;
} }
第五步：测试
public static void main(String[] args) throws Exception {
StudentDao studentDao = new StudentDao();
Student s = studentDao.getById(2);
System.out.println(s.getName());
}
2.一对多映射
根据班级名称获取学生列表信息
第一步：创建实体
Grade实体
package com.eggtwo.entity; import java.util.ArrayList;
import java.util.List; public class Grade {
private Integer id;
private String gradeName;
private List<Student> studentList = new ArrayList<Student>(); public Integer getId() {
return id;
} public void setId(Integer id) {
this.id = id;
} public String getGradeName() {
return gradeName;
} public void setGradeName(String gradeName) {
this.gradeName = gradeName;
} public List<Student> getStudentList() {
return studentList;
} public void setStudentList(List<Student> studentList) {
this.studentList = studentList;
}
}
Student实体
package com.eggtwo.entity;
import java.util.Date;
public class Student {
private Integer id;
private String name;
private Integer age;
private Date birthday;
private Boolean man;
private Grade grade;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public Boolean getMan() {
return man;
}
public void setMan(Boolean man) {
this.man = man;
}
public Grade getGrade() {
return grade;
}
public void setGrade(Grade grade) {
this.grade = grade;
}
}
第二步：建立mapper.xml
GradeMapper.xml和StudentMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--映射文件命名空间：要唯一-->
<mapper namespace="gradeDao">
<!--
*******当实体属性和表字段名称一致的话resultMap标签可以省略********
resultMap标签：映射实体和表关系
id:映射关系id,要唯一
type:实体全路径
-->
<resultMap id="gradeMap" type="com.eggtwo.entity.Grade">
<!--id：映射主键属性
result:映射非主键属性
property:实体属性名称
column:表字段名称
-->
<id property="id" column="id"/>
<result property="gradeName" column="gradeName"/>
</resultMap>
</mapper>
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--映射文件命名空间：要唯一-->
<mapper namespace="studentDao">
<resultMap id="studentMap" type="com.eggtwo.entity.Student">
<id property="id" column="id"/>
<result property="name" column="name"/>
<result property="age" column="age"/>
<result property="birthday" column="birthday"/>
<result property="man" column="man"/>
</resultMap> <select id="getListByGradeName" parameterType="string" resultMap="studentMap">
select s.id,s.name,s.age,s.birthday,s.man
from t_student s, t_grade g
where s.gradeId=g.id
and g.gradeName=#{gradeName}
</select>
</mapper>
第三步：将mapper.xml加入到mybatis.cfg.xml文件中
省略
第四步：编写StudentDao
public List<Student> getListByGradeName(String gradeName) throws Exception {
SqlSession sqlSession = null;
List<Student> studentList = null;
try {
sqlSession = MybatisUtil.getSqlSession();
studentList = sqlSession.selectList("studentDao.getListByGradeName",gradeName);
} catch (Exception e) {
e.printStackTrace();
} finally {
//关闭连接
MybatisUtil.closeSqlSession();
}
return studentList;
}
第五步：测试
List<Student> studentList = studentDao.getListByGradeName("一班");
3.自定义实体对象（不和数据库表对应）用于接收多表查询出来的复合数据
第一步：定义实体GradeStudent
package com.eggtwo.entity;
import java.util.Date;
public class GradeStudent {
private Integer gradeId;
private String gradeName;
private Integer studentId;
private String studentName;
private Integer studentAge;
private Date studentBirthday;
public Integer getGradeId() {
return gradeId;
}
public void setGradeId(Integer gradeId) {
this.gradeId = gradeId;
}
public String getGradeName() {
return gradeName;
}
public void setGradeName(String gradeName) {
this.gradeName = gradeName;
}
public Integer getStudentId() {
return studentId;
}
public void setStudentId(Integer studentId) {
this.studentId = studentId;
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
}
public Integer getStudentAge() {
return studentAge;
}
public void setStudentAge(Integer studentAge) {
this.studentAge = studentAge;
}
public Date getStudentBirthday() {
return studentBirthday;
}
public void setStudentBirthday(Date studentBirthday) {
this.studentBirthday = studentBirthday;
}
public Boolean getStudentMan() {
return studentMan;
}
public void setStudentMan(Boolean studentMan) {
this.studentMan = studentMan;
}
private Boolean studentMan;
}
第二步：定义GradeStudentMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--映射文件命名空间：要唯一-->
<mapper namespace="gradeStudentDao">
<resultMap id="gradeStudentMap" type="com.eggtwo.entity.GradeStudent"> <result property="studentId" column="studentId"/>
<result property="studentName" column="studentName"/>
<result property="studentAge" column="studentAge"/>
<result property="studentBirthday" column="studentBirthday"/>
<result property="studentMan" column="studentMan"/>
<result property="gradeId" column="gradeId"/>
<result property="gradeName" column="gradeName"/>
</resultMap> <!--返回值类型用resultMap代替resultType，可以解决实体字段类型和表字段类型不一致的问题-->
<select id="getGradeStudentList" resultMap="gradeStudentMap">
select s.id as studentId,
s.name as studentName,
s.age as studentAge,
s.birthday as studentBirthday,
s.man as studentMan,
g.id as gradeId,
g.gradeName
from t_student s, t_grade g
where s.gradeId=g.id
</select> </mapper>
第三步：将GradeStudentMapper.xml加入mybatis.xml
<mappers>
<mapper resource="com/eggtwo/entity/MemberMapper.xml"/>
<mapper resource="com/eggtwo/entity/StudentMapper.xml"/>
<mapper resource="com/eggtwo/entity/GradeMapper.xml"/>
<mapper resource="com/eggtwo/entity/GradeStudentMapper.xml"/>
</mappers>
第四步：编写dao
public List<GradeStudent> getGradeStudentList() throws Exception {
SqlSession sqlSession = null;
List<GradeStudent> gradeStudentList = null;
try {
sqlSession = MybatisUtil.getSqlSession();
gradeStudentList = sqlSession.selectList("gradeStudentDao.getGradeStudentList");
} catch (Exception e) {
e.printStackTrace();
} finally {
//关闭连接
MybatisUtil.closeSqlSession();
}
return gradeStudentList;
}
ssm整合
一、导入相关包
二、开发流程
1.写entity
package com.eggtwo.euq.entity; import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date; public class Member {
private int id; public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} private String name;
private int age;
private Date birthday;
private boolean man;
private BigDecimal score; public BigDecimal getScore() {
return score;
} public void setScore(BigDecimal score) {
this.score = score;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} public Date getBirthday() {
return birthday;
} public void setBirthday(Date birthday) {
this.birthday = birthday;
} public boolean isMan() {
return man;
} public void setMan(boolean man) {
this.man = man;
} @Override
public String toString() {
return "Member{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", birthday=" + birthday +
", man=" + man +
", score=" + score +
'}';
}
}
Member
2.配mapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--映射文件命名空间：要唯一-->
<mapper namespace="com.eggtwo.euq.dao.MemberDao">
<!--
*******当实体属性和表字段名称一致的话resultMap标签可以省略********
resultMap标签：映射实体和表关系
id:映射关系id,要唯一
type:实体全路径
-->
<resultMap id="memberMap" type="com.eggtwo.euq.entity.Member">
<!--id：映射主键属性
result:映射非主键属性
property:实体属性名称
column:表字段名称
-->
<id property="id" column="id"/>
<result property="name" column="name"/>
<result property="age" column="age"/>
<result property="birthday" column="birthday"/>
<result property="man" column="man"/>
<result property="score" column="score"/>
</resultMap> <insert id="add" parameterType="com.eggtwo.euq.entity.Member" useGeneratedKeys="true" keyProperty="id">
insert into t_member(name,age,birthday,man,score)
values(#{name},#{age},#{birthday},#{man},#{score})
</insert> <update id="update" parameterType="com.eggtwo.euq.entity.Member">
update t_member set
name = #{name},
age = #{age},
birthday = #{birthday},
man = #{man},
score = #{score}
where id = #{id}
</update> <delete id="delete" parameterType="int">
delete from t_member where id = #{id}
</delete> <!-- <select id="getById" parameterType="int" resultType="com.eggtwo.entity.Member">-->
<!--resultType使用mybatis.xml中设置的别名，这样可以简化难度-->
<select id="getById" parameterType="int" resultMap="memberMap">
select id,name,age,birthday,man,score
from t_member
where id=#{id}
</select>
<!--
理论上resultType的值应该是:List<com.eggtwo.entity.Member>
实际上只需要写List集合中的类型就可以
-->
<select id="getAll" resultMap="memberMap">
select *
from t_member
</select>
<!--分页：多参数的写法-->
<select id="getPageList" parameterType="map" resultMap="memberMap">
select id,name,age,birthday,man,score
from t_member limit #{start},#{size}
</select> <!--多条件查询-->
<select id="getListByWhere" parameterType="map" resultMap="memberMap">
select id,name,age,birthday,man,score
from t_member
<where>
<if test="name!=null and name!=''">
and name like #{name}
</if>
<if test="score!=null">
and score > #{score}
</if>
</where>
</select> <!--动态更新：可以支持部分字段更新-->
<update id="dynamicUpdate" parameterType="map">
update t_member
<set>
<if test="name!=null">
name = #{name},
</if>
<if test="age!=null">
age = #{age},
</if>
<if test="birthday!=null">
birthday = #{birthday},
</if>
<if test="man!=null">
man = #{man},
</if>
<if test="score!=null">
score = #{score},
</if>
</set>
where id=#{id}
</update> <!--根据ids数组批量删除数据-->
<delete id="batchDelete" >
delete from t_member where id in
<!--
循环数组
解析成：(1,2,34)
#id表示数组中的每一个元素，名称可以任意写
-->
<foreach collection="array" open="(" close=")" separator="," item="id">
#{id}
</foreach>
</delete>
<!--根据ids列表批量删除数据-->
<delete id="batchDeleteList" >
delete from t_member where id in
<!--
循环数组
解析成：(1,2,34)
#id表示数组中的每一个元素，名称可以任意写
-->
<foreach collection="list" open="(" close=")" separator="," item="id">
#{id}
</foreach>
</delete>
</mapper>
3.配mybatis.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--配置类的别名：使用type的地方可以直接写alias的值-->
<typeAliases>
<!--用类名做别名-->
<package name="com.eggtwo.euq.entity"/>
</typeAliases> </configuration>
4.编写dao
package com.eggtwo.euq.dao;
import com.eggtwo.euq.entity.Member;
public interface MemberDao {
public void add(Member member);
}
4.1编写service
package com.eggtwo.euq.service; import com.eggtwo.euq.dao.MemberDao;
import com.eggtwo.euq.entity.Member;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import javax.annotation.Resource; //用注解实现IOC
@Service("memberService")
public class MemberService { @Autowired
private MemberDao memberDao; public void add(Member member) throws Exception {
memberDao.add(member);
// int a = 3 / 0; }
}
5.配置spring.xml
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/tx/spring-mvc.xsd "> <!-- 配置C3P0连接池,目的：管理数据库连接 -->
<bean id="comboPooledDataSourceID" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8"/>
<property name="user" value="root"/>
<property name="password" value="123456"/> <!-- c3p0连接池的私有属性 -->
<property name="maxPoolSize" value="30" />
<property name="minPoolSize" value="10" />
<!-- 关闭连接后不自动commit -->
<property name="autoCommitOnClose" value="false" />
<!-- 获取连接超时时间 -->
<property name="checkoutTimeout" value="10000" />
<!-- 当获取连接失败重试次数 -->
<property name="acquireRetryAttempts" value="2" /> </bean> <!-- 配置SqlSessionFactoryBean，目的：加载mybaits配置文件和映射文件，即替代原Mybatis工具类的作用 -->
<bean id="sqlSessionFactoryBeanID" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="comboPooledDataSourceID"/>
<!--加载mybatis.xml文件-->
<property name="configLocation" value="classpath:mybatis.cfg.xml"/>
<!--配置扫描式加载sql映射文件，去掉mybatis.xml中的mappers-->
<property name="mapperLocations" value="classpath:com/eggtwo/euq/entity/*.xml"/>
</bean> <!-- 配置Mybatis的事务管理器，即因为Mybatis底层用的是JDBC事务管事器，所以在这里依然配置JDBC事务管理器 -->
<bean id="dataSourceTransactionManagerID" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="comboPooledDataSourceID"/>
</bean> <!-- 配置事务通知，即让哪些方法需要事务支持 -->
<tx:advice id="tx" transaction-manager="dataSourceTransactionManagerID">
<tx:attributes>
<!-- 默认只处理运行时异常，可加rollback-for="Exception/Throwable"等处理所有异常或包括错误 -->
<tx:method name="add*" propagation="REQUIRED" rollback-for="Exception"/>
<tx:method name="insert*" propagation="REQUIRED" rollback-for="Exception"/>
<tx:method name="update*" propagation="REQUIRED" rollback-for="Exception"/>
<tx:method name="delete*" propagation="REQUIRED" rollback-for="Exception"/>
<tx:method name="*" propagation="SUPPORTS"/>
</tx:attributes>
</tx:advice> <!-- 配置事务切面，即让哪些包下的类需要事务 -->
<aop:config>
<!--在service包下面使用事务-->
<aop:pointcut id="pointcut" expression="execution(* com.eggtwo.euq.service.*.*(..))"/>
<aop:advisor advice-ref="tx" pointcut-ref="pointcut"/>
</aop:config> <!-- 配置SessionTemplate，已封装了繁琐的数据操作 -->
<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg name="sqlSessionFactory" ref="sqlSessionFactoryBeanID"/>
</bean> <!-- 自动扫描组件，要把controller去除，他们是在spring-mvc.xml中配置，如果不去除会影响事务管理。 -->
<context:component-scan base-package="com.eggtwo.euq">
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan> <!-- 配置 转换器，对于在basePackage设置的包（包括子包）下的接口类，
如果接口类的全类名在Mapper.xml文件中和定义过命名空间一致，
将被转换成spring的BEAN，在调用的地方通过@Autowired方式将可以注入接口实例 -->
<!--ps:mappeer.xml中的namespace="com.eggtwo.euq.dao.MemberDao 标签：id="add"
servcie中的类在调用dao中的方法时会查找（dao.way=com.eggtwo.euq.dao.MemberDao.add）
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="sqlSessionFactory" ref="sqlSessionFactoryBeanID"/>
<property name="basePackage" value="com.eggtwo.euq.dao"/>
</bean> </beans>
6.配置springmvc.xml
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/tx/spring-mvc.xsd "> <!-- 注册Action：自动扫描 单例模式-->
<context:component-scan base-package="com.eggtwo.euq.action" /> <!-- 通知springioc容器这些注解的作用 -->
<context:annotation-config/> <!--注解映射器：可省略-->
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"></bean> <!--视图解析器-->
<!--
如果Action中书写的是视图逻辑名称，那么视图解析器就必须配置
如果Action中书写的是视图真实名称，那么视图解析器就不能配置
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 路径前缀 -->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!-- 路径后缀 -->
<property name="suffix" value=".jsp"/>
<!-- 前缀+视图逻辑名+后缀=真实路径 -->
</bean> <!-- 注册json解析适配器 -->
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
</list>
</property>
</bean>
<!-- SpringMVC上传文件时，需要配置MultipartResolver处理器 -->
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="defaultEncoding" value="utf-8"/>
<property name="maxUploadSize" value="10485760000"/>
<property name="maxInMemorySize" value="40960"/>
</bean>
</beans>
7.配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0"> <!-- Spring配置 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring.xml</param-value>
</context-param> <!-- 注册springmvc核心控制器-->
<servlet>
<!--servlet-name的值对应一个文件：/WEB-INF/DispatcherServlet-servlet.xml -->
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<!-- 指定application.xml文件 -->
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping> <!--spring编码过滤器：解决POST提交中文乱码问题-->
<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>
8.编写action
package com.eggtwo.euq.action; import com.eggtwo.euq.entity.Member;
import com.eggtwo.euq.service.MemberService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod; import java.math.BigDecimal;
import java.util.Date; @Controller
@RequestMapping("member")
public class MemberController extends BaseController {
@Autowired
private MemberService memberService;
@RequestMapping(value = "add", method = RequestMethod.GET)
public String add(Model model) { try{
Member member = new Member();
member.setName("旺旺");
member.setScore(new BigDecimal(12));
member.setMan(new Boolean(true));
member.setBirthday(new Date());
member.setAge(14);
memberService.add(member);
}catch (Exception e){
e.printStackTrace();
}
return "member/add"; }
}
Maven
1.解决的问题
jar包的依赖和管理：版本、依赖关系等
自动构建项目
2.maven介绍
1、Maven是什么？
Apache Maven是一个软件项目管理的综合工具。基于项目对象模型（POM）的概念，提供了帮助管理构建、文档、报告、依赖、发布等方法，Maven简化和标准化项目建设过程。处理编译，分配，文档，团队协作和其他任务的无缝连接。 Maven增加可重用性并负责建立相关的任务。
2、Maven好处
可以将项目过程规范化、自动化、高效化以及强大的可扩展性，利用maven自身及其插件还可以获得代码检查报告、单元测试覆盖率、实现持续集成等等。
使得项目的管理变得容易，构建项目的速度更快，由于Maven提供了仓库的概念去管理jar包，所以用git或者svn的时候，存储构建的项目体积会更小。
3、Maven可以做什么？
管理项目的构建、文档生成、报告、依赖、SCMs(software configuration Management)、分布、分发、邮件列表
4、Maven的基本原理
采用远程仓库和本地仓库以及一个核心的配置文件pom.xml，pom.xml中定义的jar文件从远程仓库下载到本地仓库，各个项目使用同一个本地仓库的jar，同一个版本的jar只需下载一次，而且避免每个应用都去拷贝jar。同时它采用了现在流行的插件体系架构，所以maven的核心非常的小，只有几兆大小的文件，在执行maven任务时，才会自动下载需要的插件。
3.maven安装
3.1下载
http://maven.apache.org/download.cgi
3.2安装
解压到文件夹
Maven根目录文件：
（1）bin：Maven的运行脚本。bin\mvn.cmd是基于windows的脚本。在cmd中每输入一条mvn的命令都是在调用并执行这些脚本。
（2）boot：该项目只有一个文件plexus-classworlds-2.6.0.jar。他是一个类加载器的框架，相当于对JDK中的类的加载器，提供了丰富的语法以此用来方便配置，Maven使用该框架加载自己的类库。
（3）conf：该目录包含了一个非常重要的文件setting.xml。配置该文件就可以在Project中定制Maven的行为。
（4）lib：包含了所有Maven运行时需要的Java类库以及用到的第三方类库。
（5）LICENSE：软件许可
（6）NOTICE：软件引用的三方软件
（7）README.txt：包含了Maven的简介
配置环境变量：path
测试：
4.maven使用
0.maven项目创建及结构
mavenProject
src
main
java
包:com.eggtwo
resource
test
java
pom.xml（project object model）
1.创建maven仓库文件夹：D:\Java\maven_repository\repository
2.配置仓储的路径：打开D:\Java\apache-maven-3.6.2\conf下的settings.xml文件，
3.maven命令使用
先进入到maven项目目录
编译：mvn compile
测试：maven test
清除：maven clean
打包：maven package 打包会走编译、测试
安装：maven install 会打包后放到maven仓库给其它项目使用
4.配置jar包下载地址
默认从中心仓下载：https://repo.maven.apache.org/maven2
配置的下载地址在：D:\Java\apache-maven-3.6.2\lib\maven-model-builder-3.6.2.jar 中的pom-4.0.0.xml
下载到我们配置的仓库路径下
5.maven坐标：项目的唯一标识
groupId+artifactId+version
groupId:组id，机构名，公司名，公司的包
artifactId：产品名或者产品id
6.pom.xml详解
5.idea 创建maven项目
第一步：
第二步：
第三步：选择maven
archetypeCatalog=internal
第四步：
第五步：
第六步：
第七步：
第八步：配置tomcat
第九步：
运行：http://localhost:8080/firstMaven/
第十步：完善maven的目录
重点：创建文件夹，然后设置文件夹类型
然后右击新建的文件夹设置其类型为：Sources(源码)、Test（测试）、Resources（资源文件）
完整的项目结构如下：
6.idea maven mybatis逆向工程（代码生成器）
1.配置pom.xml
在plugins标签下添加mybatis-generator-maven-plugin
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.2</version>
<configuration>
<verbose>true</verbose>
<overwrite>true</overwrite>
</configuration>
</plugin>
2.配置generatorConfig.xml
在resources文件夹下新建generatorConfig.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd"> <generatorConfiguration>
<!--导入属性配置-->
<properties resource="generator.properties"></properties> <!--指定特定数据库的jdbc驱动jar包的位置-->
<classPathEntry location="${jdbc.driverLocation}"/> <context id="default" targetRuntime="MyBatis3"> <!-- optional，旨在创建class时，对注释进行控制 -->
<commentGenerator>
<!-- 是否生成注释代时间戳 -->
<property name="suppressDate" value="true"/>
<!-- 是否取消注释 -->
<property name="suppressAllComments" value="true"/>
</commentGenerator> <!--jdbc的数据库连接 -->
<jdbcConnection
driverClass="${jdbc.driverClass}"
connectionURL="${jdbc.connectionURL}"
userId="${jdbc.userId}"
password="${jdbc.password}">
</jdbcConnection> <!-- 非必需，类型处理器，在数据库类型和java类型之间的转换控制-->
<javaTypeResolver>
<property name="forceBigDecimals" value="false"/>
</javaTypeResolver> <!-- Model模型生成器,用来生成含有主键key的类，记录类 以及查询Example类
targetPackage 指定生成的model生成所在的包名
targetProject 指定在该项目下所在的路径
-->
<javaModelGenerator targetPackage="com.eggtwo.entity"
targetProject="src/main/java"> <!-- 是否允许子包，即targetPackage.schemaName.tableName -->
<property name="enableSubPackages" value="false"/>
<!-- 是否对model添加 构造函数 -->
<property name="constructorBased" value="false"/>
<!-- 是否对类CHAR类型的列的数据进行trim操作 -->
<!-- 去除字段前后空格 -->
<property name="trimStrings" value="true"/>
<!-- 建立的Model对象是否 不可改变 即生成的Model对象不会有 setter方法，只有构造方法 -->
<property name="immutable" value="false"/>
</javaModelGenerator> <!--Mapper映射文件生成所在的目录 为每一个数据库的表生成对应的SqlMap文件 -->
<sqlMapGenerator targetPackage="com.eggtwo.entity"
targetProject="src/main/java">
<property name="enableSubPackages" value="false"/>
</sqlMapGenerator> <!-- dao客户端代码，生成易于使用的针对Model对象和XML配置文件 的代码
type="ANNOTATEDMAPPER",生成Java Model 和基于注解的Mapper对象
type="MIXEDMAPPER",生成基于注解的Java Model 和相应的Mapper对象
type="XMLMAPPER",生成SQLMap XML文件和独立的Mapper接口
-->
<javaClientGenerator targetPackage="com.eggtwo.dao"
targetProject="src/main/java" type="XMLMAPPER">
<property name="enableSubPackages" value="true"/>
</javaClientGenerator> <table tableName="t_member" domainObjectName="Member"
enableCountByExample="false" enableUpdateByExample="false"
enableDeleteByExample="false" enableSelectByExample="false"
selectByExampleQueryId="false">
</table> </context>
</generatorConfiguration>
里面引用了数据库配置文件：
在resources文件夹下新建generator.properties
## mysql驱动文件对应的路径，不要和项目引用的mysql驱动jar位置一致
jdbc.driverLocation=D:\\Java\\jars\\mysql-connector-java-5.1.7-bin.jar
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.connectionURL=jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=false
jdbc.userId=root
jdbc.password=123456
3.配置基于maven的mybatis generate命令
mybatis-generator:generate -e
4.运行生成命令：
选择mybatis-generate，然后点击运行
atisUtil
mybatis-generator-maven-plugin
java web开发入门汇总的更多相关文章
- day04 Java Web 开发入门
day04 Java Web 开发入门 1. web 开发相关介绍 2. web 服务器 3. Tomcat服务器启动的问题 4. Tomcat目录结构 5. Web应用程序(虚拟目录映射,缺省web ...
- java WEB开发入门
WEB开发入门 1 进入web JAVASE:标准- standard JAVA桌面程序 GUI SOCKET JAVAEE:企业-浏览器控制 web 2 软件结构 C/S :client ...
- java web 开发入门实例
学习是个技巧活,关键是要找到重点的地方,新手在这方面的坑尤其多.看别人的教程一步一步的跟着做,隔几步就遇到一个新知识点,忍不住就百度往深处了解,一晃半天就过去了. 有的知识点要深入学习的,有的是了解下 ...
- java web 开发入门 --- tomcat/servlet/jsp
在做java web 开发时,要先安装tomcat.它是一个web服务器,也叫web容器,我们把写好的jsp, html页面放到它里面,然后启动它,就可以用浏览器访问这些页面,地址栏中输入localh ...
- java web 开发入门
Java web,是java技术用来解决web互联网领域的技术总和.Java web技术主要包括客户端和服务端,java在客户端的服务有java applet,不过用的非常少,大部分应用在服务端,比如 ...
- Java开发工程师(Web方向) - 01.Java Web开发入门 - 第6章.蜂巢
第6章--蜂巢 蜂巢简介 网站开发完,就需要测试.部署.在服务器上运行. 网易蜂巢: 采用Docker容器化技术的云计算平台 https://c.163.com 容器管理:容器可被视作为云主机的服务器 ...
- Java开发工程师(Web方向) - 01.Java Web开发入门 - 第4章.Maven
第4章--Maven Maven实战 Java Web应用的部署: 手动式: 编译:javac -cp $CATALINA_HOME/lib/servlet-api.jar web-inf/class ...
- Java开发工程师(Web方向) - 01.Java Web开发入门 - 第3章.Tomcat
第3章--Tomcat Tomcat安装与运行 Tomcat:目前最常用的基于java的web应用服务器 本课程中所有的Java代码最终都需要部署到Tomcat中运行 Tomcat的配置文件是XML的 ...
- java web开发入门一（servlet和jsp）基于eclispe
servlet 用java语言开发动态资源网站的技术,在doGet方法中拼接显示html,在doPost方法中提交数据.类似于.net的ashx技术. servlet生成的class文件存放在tomc ...
随机推荐
- Linux系统安装snmp服务
Linux安装snmp详解 Snmp一种网络之间的传输协议,通过snmp可以采集很多指标比如cpu.内存及磁盘的信息,现在越来越多的网络设备基本上都支持snmp,本文介绍了snmp的安装过程. 二.安 ...
- Blackbox_exporter黑盒监测
一.概述 blackbox_exporter是Prometheus 官方提供的 exporter 之一,可以提供 http.dns.tcp.icmp 的监控数据采集.Blackbox_exporter ...
- AtCoder diverta 2019 Programming Contest 2
AtCoder diverta 2019 Programming Contest 2 看起来我也不知道是一个啥比赛. 然后就写写题解QWQ. A - Ball Distribution 有\(n\)个 ...
- golang学习笔记 ---slice
Go 语言中的slice类型可以理解为是数组array类型的描述符,包含了三个因素: 指向底层数组的指针 slice目前使用到的底层数组的元素个数,即长度 底层数组的最大长度,即容量 因此当我们定义一 ...
- Java-Queue总结
1. ConcurrentLinkedQueue 基础链表同步队列. import java.util.Queue; import java.util.concurrent.ConcurrentLin ...
- 史上最全的音视频SDK包分享给大家
史上最全的音视频SDK包分享给大家 概述一下SDK功能: 项目 详情视频通信 支持多种分辨率的视频通信语音通信 提供语音通信,可支持高清宽带语音动态创建房间 可以根据需要,随时创建房间H5 支持 ...
- Python——XPath提取某个标签下所有文本
/text()获取指定标签下的文本内容,//text()获取指定标签下的文本内容,包括子标签下的文本内容,比较简单的是利用字符串相加: room_infos = li.xpath('.//a[@cla ...
- Python基础14
P73. 内嵌函数的讲解介绍 内部函数,书中讲的应用较简单,后面找篇具体的文章学习下
- Linux关机重启注销(3)
1.关机重启 shutdown shutdown -h now :立即关机 shutdown -h 1 now :一分钟后关机 shutdown -r now :立即重启 halt:关机 reboot ...
- FCC-学习笔记 Pig Latin
FCC-学习笔记 Pig Latin 1>最近在学习和练习FCC的题目.这个真的比较的好,推荐给大家. 2>中文版的地址:https://www.freecodecamp.cn/;英文版 ...