java web开发入门汇总

本文转载自查看原文 2019-10-31 15:44 373 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 自定义标签

开发步骤：

编写一个普通的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>

View Code

项目结构：

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;
    }



}

View Code

数据库表结构：

映射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>

View Code

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>

View Code

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();
    }

}

View Code

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("销毁了对象");
    }
}

View Code

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>

View Code

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>

View Code

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>

View Code

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>

View Code

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>

View Code

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>

View Code

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;
    }

}

View Code

注解实现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>

View Code

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>

View Code

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:不允许为空
    }
}

View Code

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;
    }
}

View Code

定义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>

View Code

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>

View Code

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();
        }
    }






}

View Code

5.定义MemberDao测试mybatis增删查改

View Code

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());
        }
    }

View Code

二、动态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>

View Code

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>

View Code

第三步：将mapper.xml加入到mybatis.cfg.xml文件中

    <mappers>
        <mapper resource="com/eggtwo/entity/StudentMapper.xml"/>
        <mapper resource="com/eggtwo/entity/GradeMapper.xml"/>
    </mappers>

View Code

第四步：编写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;
    }

    
}

View Code

第五步：测试

 public static void main(String[] args) throws Exception {

        StudentDao studentDao = new StudentDao();
        Student s = studentDao.getById(2);
        System.out.println(s.getName());
    }

View Code

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;
    }
}

View Code

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;
    }
}

View Code

第二步：建立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>

View Code

<?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>

View Code

第三步：将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;
    }

View Code

第五步：测试

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;
}

View Code

第二步：定义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>

View Code

第三步：将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>

View Code

第四步：编写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;
    }

View Code

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>

View Code

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>

View Code

4.编写dao

package com.eggtwo.euq.dao;

import com.eggtwo.euq.entity.Member;

public interface MemberDao {
    public void  add(Member member);
}

View Code

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;

    }
}

View Code

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&amp;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>

View Code

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>

View Code

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>

View Code

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";


    }
}

View Code

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>

View Code

里面引用了数据库配置文件：

在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

免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。

猜您在找 JAVA WEB开发中处理乱码汇总 Java Web开发后端常用技术汇总 Java Web开发后端常用技术汇总 java web 开发入门 --- tomcat/servlet/jsp javaEE(1)_web开发入门 Web后端开发学习教程汇总篇 PHP Web开发入门流程 Java和Python的Web开发 Java Web开发模式【问题】web前端开发常见问题汇总