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前端開發常見問題匯總