java web開發入門
servlet
用java語言開發動態資源網站的技術，在doGet方法中拼接顯示html，在doPost方法中提交數據。相似於.net的ashx技術。html
servlet生成的class文件存放在tomcat中webapps目錄下。java
1.開發一個servlet步驟：mysql
1）在src下新建包並編寫java類，繼承HttpServlet類程序員
2）重寫doGet和doPost方法web
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的生命週期spring
構造方法： 建立servlet對象的時候調用。默認狀況下，第一次訪問servlet的時候建立servlet對象 只調用1次。證實servlet對象在tomcat是單實例的。sql
init方法： 建立完servlet對象的時候調用。只調用1次。數據庫
service方法： 每次發出請求時調用。調用n次。express
destroy方法： 銷燬servlet對象的時候調用。中止服務器或者從新部署web應用時銷燬servlet對象。 只調用1次。apache
JSP
1.特色：
用java語言+html開發動態網站的技術。jsp就是servlet（）。
相似於.net的webform，jsp頁面能夠java語言和html混合寫。
tomcat的work目錄存放jsp運行的臨時文件（.java和.class文件），在運行jsp頁面時動態生成並 執行。
訪問方式：http://localhost:8080/javaweb/hello.jsp
2.建立方式：
在WebRoot下建立jsp頁面。
<%@page import="java.util.Date"%> <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <!DOCTYPE html> <html> <head> <meta charset="ISO-8859-1"> <title>Insert title here</title> </head> <body> <% out.write("hello"); Date dt=new Date(); String s=dt.toLocaleString(); %> <h3><%=s %></h3> </body> </html>
3.生命週期：
1）翻譯： jsp->java文件
2）編譯： java文件->class文件（servlet程序）
3）構造方法（第1次訪問）
4）init方法（第1次訪問）：_jspInit()
5）service方法：_jspService()
6）destroy方法：_jspDestroy()
4.jsp語法
4.1jsp表達式：
語法：<%=變量或表達式%>
做用： 向瀏覽器輸出變量的值或表達式計算的結果
注意：
1）表達式的原理就是翻譯成out.print(「變量」 );經過該方法向瀏覽器寫出內容
2）表達式後面不須要帶分號結束。
4.2jsp腳本
語法：<% java代碼 %>
做用： 執行java代碼
注意：原理把腳本中java代碼原封不動拷貝到_jspService方法中執行，不能聲明方法
4.3jsp的聲明
語法：<%! 變量或方法 %>
做用： 聲明jsp的變量或方法
注意:
1）變量翻譯成成員變量，方法翻譯成成員方法。
4.4jsp的註釋
語法： <%-- jsp註釋 --%>
注意;
1)html的註釋會被翻譯和執行。而jsp的註釋不能被翻譯和執行。
4.5jsp指令
include指令：
做用： 在當前頁面用於包含其餘頁面，相似於.net mvc中的分佈視圖
語法： <%@include file="common/header.jsp"%>
注意：
1）原理是把被包含的頁面（header.jsp）的內容翻譯到包含頁面(index.jsp)中,合併成翻譯成一 個java源文件，再編譯運行！！，這種包含叫靜態包含（源碼包含）
2）若是使用靜態包含，被包含頁面中不須要出現全局的html標籤了！！！（如html、head、 body）
page指令：
做用： 告訴tomcat服務器如何翻譯jsp文件
<%@ page language="java" --告訴服務器使用什麼動態語言來翻譯jsp文件 import="java.util.*" --告訴服務器java文件使用什麼包導入包，多個包之間用逗號分割 pageEncoding="utf-8" --告訴服務器使用什麼編碼翻譯jsp文件（成java文件） contentType="text/html; charset=utf-8" 服務器發送瀏覽器的數據類型和內容編碼，注意：在開發工具中，之後只須要設置pageEncoding便可解決中文亂碼問題 errorPage="error.jsp" --指定當前jsp頁面的錯誤處理頁面。 isErrorPage="false" --指定當前頁面是否爲錯誤處理頁面。false，不是錯誤處理頁面，則不能使用exception內置對象；true，是錯誤處理頁面，可使用exception內置對象。 buffer="8kb" --jsp頁面的緩存區大小 session="true" --是否開啓session功能。false，不能用session內置對象；true，可使用session內置對象。 isELIgnored="false" --是否忽略EL表達式 %>
配置全局的錯誤處理頁面：
在web.xml中的web-app節點下配置：
<!-- 全局錯誤處理頁面配置 --> <error-page> <error-code>500</error-code> <location>/common/500.jsp</location> </error-page> <error-page> <error-code>404</error-code> <location>/common/404.html</location> </error-page>
5.jsp內置對象
JSP內置對象(9個內置對象):
1.pageContext javax.servlet.jsp.PageContext JSP的頁面容器
2.request javax.servlet.http.HttpServletrequest 獲取用戶的請求信息
3.response javax.servlet.http.HttpServletResponse 服務器向客戶端的迴應信息
4.session javax.servlet.http.HttpSession 用來保存每個用戶的信息
5.application javax.servlet.ServletContext 表示全部用戶的共享信息
6.config javax.servlet.ServletConfig 服務器配置信息，能夠取得初始化參數
7.out javax.servlet.jsp.jspWriter 頁面輸出
8.page (java.lang.object)
9.exception java.lang.Throwable
4個域對象的範圍:用於共享數據（設置、獲取、刪除）
page(pageContext):只在當前jsp頁面中有效， 跳轉以後無效。
request:只在一次請求中有效，服務器跳轉(轉發)以後有效。 客戶端跳無效
session:在一次會話中有效。服務器跳轉、客戶端跳轉都有效。 網頁關閉從新打開無效
application:在整個服務器上保存，全部用戶均可使用。 重啓服務器後無效
<% pageContext.setAttribute("age", 18); pageContext.setAttribute("tom", 11,pageContext.REQUEST_SCOPE); request.setAttribute("name","jack"); session.setAttribute("lily", 12); application.setAttribute("全局",12); %> <h1>${name}</h1> <h1>${tom}</h1> <h1>${age}</h1> <h1>${lily}</h1> <h1>${全局}</h1>
域對象保存值，取值，刪除的方法
//設置值 pageContext.setAttribute("age", 18); //取值 Object obj=pageContext.getAttribute("age"); if(obj==null){ out.write("已刪除"); }else{ //數字直接試用out.write輸出會亂碼 int age=Integer.parseInt(obj.toString()); out.write(Integer.toString(age)); //或者 //out.write(obj.toString()); } out.write("<br/>"); pageContext.removeAttribute("age"); Object obj1=pageContext.getAttribute("age"); if(obj1==null){ out.write("已刪除"); }else{ out.write(obj1.toString()); }
注意：若是設置過多的application屬性範圍會影響服務器性能。
pageContext.PAGE_SCOPE
pageContext.REQUEST_SCOPE
pageContext.SESSION_SCOPE
pageContext.APPLICATION_SCOPE
pageContext.setAttribute("name", "liuyang", pageContext.APPLICATION_SCOPE);
6.EL表達式
6.1 做用
jsp的核心語法： jsp表達式 <%=%>和 jsp腳本<% %>。
之後開發jsp的原則： 儘可能在jsp頁面中少寫甚至不寫java代碼。
使用EL表達式替換掉jsp表達式
EL表達式做用： 向瀏覽器輸出域對象中的變量值或表達式計算的結果！！！
語法： ${變量或表達式}
6.2EL語法
1）輸出基本數據類型變量
1.1 從四個域獲取
${name}
1.2 指定域獲取
${pageScope.name}
1.3 輸出對象屬性：student.name 注意：.name 至關於 getName()方法，其中name和Name要對應
域範圍： pageScoep / requestScope / sessionScope / applicationScope
2）處理集合${studentList[0].name}
3)表達式計算 ${10+1}
7.jsp標籤
7.1 jsp標籤做用：
替換jsp腳本
7.2 Jsp標籤分類：
1）內置標籤（動做標籤）： 不須要在jsp頁面導入標籤
2）jstl標籤： 須要在jsp頁面中導入標籤
3）自定義標籤 ： 開發者自行定義，須要在jsp頁面導入標籤
內置標籤（動做標籤）：
轉發標籤： <jsp:forward />
參數標籤： <jsp:pararm/>
例如：內部跳轉到second.jsp並帶上參數name=jack
<jsp:forward page="second.jsp"> <jsp:param value="name" name="jack"/> </jsp:forward>
等同於
request.getRequestDispatcher("second.jsp?name=jack").forward(request, response);
包含標籤： <jsp:include/>
<%@include file="common.jsp" %> <jsp:include page="comm.jsp"> <jsp:param value="name" name="jack"/> </jsp:include>
靜態包含語法： <%@inclue file="被包含的頁面"%>
動態包含語法： <jsp:include page="被包含的頁面">
靜態包含： 先合併再翻譯
動態包含： 先翻譯再合併
7.3 JSTL標籤
JSTL (全名：java standard tag libarary - java標準標籤庫 )
五套標籤庫：
1.核心標籤庫 （c標籤庫） 每天用
2.國際化標籤（fmt標籤庫）
3.EL函數庫（fn函數庫）
4.xml標籤庫（x標籤庫）
5.sql標籤庫（sql標籤庫）
使用JSTL標籤步驟
1） Eclispe須要導入jstl支持的jar包（標籤背後隱藏的java代碼）注意：MyEclispe使用javaee5.0的項目自動導入jstl支持jar包
eclispe導入方式：將standard.jar和jstl.jar文件拷貝到工程的\WEB-INF\lib\下，而後build path
2）使用taglib指令導入標籤庫 <%@taglib uri="tld文件的uri名稱" prefix="簡寫" %>
例如：在jsp頁面導入核心標籤庫：
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
3）在jsp中使用jstl標籤
保存數據： <c:set></c:set>
<%-- set標籤：保存值到域中 var:值的名稱 value：值 scope:值的範圍，page,request,session,application --%> <c:set var="sex" value="man" scope="request"></c:set>
獲取數據：<c:out value=""></c:out>
<%-- out標籤：獲取域中設置的數據 default：當value爲null時，使用默認值 escapeXml:是否對value進行轉義，false不轉義，true轉義 --%> <c:out value="${sex}" default="<h1>默認值</h1>" escapeXml="true"></c:out>
單條件判斷： <c:if test=""></c:if>
<%--if標籤：單條件判斷 --%> <c:if test="${5>3}">
多條件判斷：
<c:choose></c:choose>
<c:when test=""></c:when>
<c:otherwise></c:otherwise>
<c:set var="score" value="80"></c:set> <c:choose> <c:when test="${score>90}"> 優秀 </c:when> <c:when test="${score<=90&&score>60}"> 良好 </c:when> <c:otherwise> 差 </c:otherwise> </c:choose>
循環數據：
<c:forEach></c:forEach>
<% ArrayList<String> list=new ArrayList<String>(); list.add("tom"); list.add("jack"); list.add("jack"); pageContext.setAttribute("list", list); %> <%--forEach循環 begin:從哪一個元素開始，默認從0開始 end:到哪一個元素結束 step:每次的增量 items：要遍歷的數據 var：每一個元素的名稱 varStatus:正在遍歷的元素的狀態對象，count屬性默認從1開始 --%> <c:forEach begin="0" end="2" step="1" items="${list}" var="names" varStatus="varSta"> <h4>順序：${varSta.count}，${names}</h4> </c:forEach>
<c:forTokens items="" delims="" var=""></c:forTokens>
<% String sps="a-b-c"; pageContext.setAttribute("sps",sps); %> <c:forTokens items="${sps}" delims="-" var="ss"> <h5>${ss}</h5> </c:forTokens>
重定向：<c:redirect url=""></c:redirect>
<c:redirect url="http://www.baidu.com"> </c:redirect>
7.4 自定義標籤
開發步驟：
1.
編寫一個普通的java類，繼承SimpleTagSupport類，叫標籤處理器類
public class ShowIpTag extends SimpleTagSupport { @Override public void doTag() throws JspException, IOException { // 向瀏覽器輸出客戶的ip地址 PageContext pageContext = (PageContext) getJspContext(); HttpServletRequest request = (HttpServletRequest) pageContext.getRequest(); String ip = request.getRemoteHost(); JspWriter out = pageContext.getOut(); out.write("使用自定義標籤輸出客戶IP地址：" + ip); } }
2）在web項目的WEB-INF目錄下創建eggtwo.tld文件，這個tld叫標籤庫的聲明文件。（參考核心標籤庫的tld文件）
<?xml version="1.0" encoding="UTF-8" ?> <taglib xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd" version="2.1"> <!-- 標籤庫版本 --> <tlib-version>1.1</tlib-version> <!-- 標籤庫前綴版本 --> <short-name>eggtwo</short-name> <!--tld文件的惟一標記，完整的uri --> <uri>http://tag.eggtwo.com</uri> <tag> <!--標籤名稱tld文件的惟一標記 --> <name>showIp</name> <!--標籤處理器類的全稱（包名+類名） --> <tag-class>com.eggtwo.boss.ShowIpTag</tag-class> <!--輸出內容的格式 --> <body-content>scriptless</body-content> </tag> </taglib>
3） 在jsp頁面的頭部導入自定義標籤庫
<%@taglib prefix="eggtwo" uri="http://tag.eggtwo.com" %>
4） 在jsp中使用自定義標籤
<eggtwo:showIp></eggtwo:showIp>
JavaBean
JavaBean, 咖啡豆。 JavaBean是一種開發規範，能夠說是一種技術。
JavaBean就是一個普通的java類。只有符合如下規定才能稱之爲javabean：
1）必須提供無參數的構造方法
2）類中屬性都必須私有化(private)
3）該類提供公開的getter 和 setter方法
getName() setName(String name)
注意： boolean類型的get方法名稱叫 isXXX()方法 public boolean isAcitve()
JavaBean的做用： 用於封裝數據，保存數據。
訪問javabean只能使用getter和setter方法
JavaBean的使用場景：
1）項目中用到實體對象（entity）符合javabean規範
2）EL表達式訪問對象屬性。${student.name} 調用getName()方法，符合javabean規範。
3）jsp標籤中的屬性賦值。 setNum（Integer num）。符合javabean規範。
4）jsp頁面中使用javabean。符合javabean規範
mysql
struts
struts是對servlet的封裝
1.開發步驟
1.下載struts 開發庫：http://struts.apache.org 下載點擊下載：struts-*-all.zip版本 ，使用2.3版本
2.在項目lib下面導入struts必須的包，而後build path
commons-fileupload-1.2.2.jar 【文件上傳相關包】
commons-io-2.0.1.jar
struts2-core-2.3.4.1.jar 【struts2核心功能包】
xwork-core-2.3.4.1.jar 【Xwork核心包】
ognl-3.0.5.jar 【Ognl表達式功能支持表】
commons-lang3-3.1.jar 【struts對java.lang包的擴展】
freemarker-2.3.19.jar 【struts的標籤模板庫jar文件】
javassist-3.11.0.GA.jar 【struts對字節碼的處理相關jar】
3.配置web.xml
<!-- 引入struts核心過濾器 --> <filter> <filter-name>struts2</filter-name> <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class> </filter> <filter-mapping> <filter-name>struts2</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
4.開發action
在src下面建立struts的action，繼承ActionSupport
//開發action： 處理請求 public class HelloAction extends ActionSupport { // 處理請求 public String execute() throws Exception { System.out.println("訪問到了action，正在處理請求"); System.out.println("調用service"); return "success"; } }
5.在src下面添加struts.xml文件（能夠在struts包中搜索）
一個struts.xml中能夠有多個package，可是package的名稱不能重複
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd"> <struts> <!-- name任意名稱，extends固定寫法 --> <package name="mystruts" extends="struts-default"> <!-- name：瀏覽器要訪問的名稱，class：編寫的action全稱，method：action下面的方法 --> <action name="hello" class="com.eggtwo.action.HelloAction" method="execute"> <!-- name:返回值， 跳轉地址 --> <result name="success">/index.jsp</result> </action> </package> </struts>
5.1struts.xml的第二種配置方式：
在src下面添加總的struts.xml文件，而後在總文件中引用各個包中的struts.xml文件
總struts.xml文件：
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd"> <struts> <!-- 總配置文件：引用其餘包中的獨立的配置文件 --> <include file="com/eggtwo/action/struts.xml"></include> </struts>
包中的struts.xml文件：
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd"> <struts> <!-- name任意名稱，extends:繼承的類 --> <package name=com.eggtwo.action namespace="/" extends="struts-default" abstract="false"> <!-- name：瀏覽器要訪問的名稱，class：編寫的action全稱，method：action下面的方法 --> <action name="execute" class="com.eggtwo.action.HelloAction" method="execute"> <!-- name:返回值， 跳轉地址 --> <result name="success" >/index.jsp</result> </action> <action name="login" class="com.eggtwo.action.LoginAction" method="login"> <!-- name:返回值， 跳轉地址 --> <result name="success" >/login.jsp</result> </action> </package> </struts>
項目結構：
2.執行流程
服務器啓動：
1. 加載項目web.xml
2. 建立Struts核心過濾器對象， 執行filter -> init()
struts-default.xml, 核心功能的初始化
struts-plugin.xml, struts相關插件
struts.xml 用戶編寫的配置文件
訪問：
3. 用戶訪問Action, 服務器根據訪問路徑名稱，找對應的aciton配置, 建立action對象
4. 執行默認攔截器棧中定義的18個攔截器
5. 執行action的業務處理方法
Hibernate
1.開發流程
項目配置好後的結構：
1.下載源碼： 版本：hibernate-distribution-3.6.0.Final
2.引入hibernate須要的開發包（3.6版本），若是沒有引用成功，在jar包上右鍵執行：add as library
3.編寫實體對象及對象的映射xml文件
實體類：
package com.eggtwo.test; import java.util.Date; public class Student { private int id; private String name; private int age; private Date birthday; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Date getBirthday() { return birthday; } public void setBirthday(Date birthday) { this.birthday = birthday; } }
數據庫表結構：
映射xml文件：（放在包下面）
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.eggtwo.test"> <class name="Student" table="student"> <!-- 主鍵 ，映射--> <id name="id" column="id"> <generator class="native"/> </id> <!-- 非主鍵，映射 --> <property name="name" column="name"></property> <property name="age" column="age"></property> <property name="birthday" column="birthday"></property> </class> </hibernate-mapping>
4.配置主配置文件：src/hibernate.cfg.xml
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <!-- 數據庫鏈接配置 --> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql:///test</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">123456</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property> <property name="hibernate.show_sql">true</property> <!-- 加載全部映射 --> <mapping resource="com/eggtwo/test/Student.hbm.xml"/> </session-factory> </hibernate-configuration>
5.測試添加一條數據：
package com.eggtwo.test; import java.util.Date; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration; import org.junit.Test; public class TestApp { @Test public void testHello() throws Exception { // 建立對象：主鍵自增加 Student s = new Student(); s.setAge(12); s.setName("班長"); s.setBirthday(new Date()); // 獲取加載配置文件的管理類對象 Configuration config = new Configuration(); config.configure(); // 默認加載src/hibenrate.cfg.xml文件 // 建立session的工廠對象 SessionFactory sf = config.buildSessionFactory(); // 建立session (表明一個會話，與數據庫鏈接的會話) Session session = sf.openSession(); // 開啓事務 Transaction tx = session.beginTransaction(); //保存-數據庫 session.save(s); // 提交事務 tx.commit(); System.out.println("save success"); // 關閉 session.close(); sf.close(); } }
2.映射詳解
spring
ssh=struts(controller)+spring(service)+hibernate(dao)
1.spring簡介
Spring框架，能夠解決對象建立以及對象之間依賴關係的一種框架。
且能夠和其餘框架一塊兒使用；Spring與Struts, Spring與hibernate
(起到整合（粘合）做用的一個框架)
Spring提供了一站式解決方案：
1） Spring Core spring的核心功能： IOC容器, 解決對象建立及依賴關係
2） Spring Web Spring對web模塊的支持。
-à 能夠與struts整合,讓struts的action建立交給spring
-à spring mvc模式
3） Spring DAO Spring 對jdbc操做的支持 【JdbcTemplate模板工具類】
4） Spring ORM spring對orm的支持：
à 既能夠與hibernate整合，【session】
à 也可使用spring的對hibernate操做的封裝
5）Spring AOP 切面編程
6）SpringEE spring 對javaEE其餘模塊的支持
2.spring開發步驟
1.下載引用開發包
spring各個版本中：
在3.0如下的版本，源碼有spring中相關的全部包【spring功能 + 依賴包】
如2.5版本；
在3.0以上的版本，源碼中只有spring的核心功能包【沒有依賴包】
(若是要用依賴包，須要單獨下載！)
源碼, jar文件：spring-framework-3.2.5.RELEASE
commons-logging-1.1.3.jar 日誌
spring-beans-3.2.5.RELEASE.jar bean節點
spring-context-3.2.5.RELEASE.jar spring上下文節點
spring-core-3.2.5.RELEASE.jar spring核心功能
spring-expression-3.2.5.RELEASE.jar spring表達式相關表
以上是必須引入的5個jar文件！
2.在src下面的包中建立Student對象：
package com.eggtwo.test; public class Student { private int age; private String name; public Student(){ super(); System.out.println("調用了student的構造函數"); } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void init_student() { System.out.println("初始化了對象"); } public void destroy_student() { System.out.println("銷燬了對象"); } }
3.在src下面的包中引入核心配置文件： applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- 1) 對象建立： 單例/多例 scope="singleton", 默認值， 即 默認是單例 【service/dao/工具類】 scope="prototype", 多例； 【Action對象】 2) 何時建立? scope="prototype" 在用到對象的時候，才建立對象。 scope="singleton" 在啓動(容器初始化以前)， 就已經建立了bean，且整個應用只有一個。 3)是否延遲建立 lazy-init="false" 默認爲false, 不延遲建立，即在啓動時候就建立對象 lazy-init="true" 延遲初始化， 在用到對象的時候才建立對象（只對單例有效） 4) 建立對象以後，初始化/銷燬 init-method="init_student" 【對應對象的init_student方法，在對象建立愛以後執行 】 destroy-method="destroy_student" 【在調用容器對象的destriy方法時候執行，(容器用實現類)】 --> <bean id="student" class="com.eggtwo.test.Student" scope="prototype" lazy-init="false" init-method="init_student" destroy-method="destroy_student"></bean> </beans>
4.使用pring建立對象：getBean中的參數是xml中設置的id
package com.eggtwo.test; import org.junit.Test; import org.springframework.context.support.ClassPathXmlApplicationContext; public class APPTest { @Test public void test(){ // 獲得IOC容器對象 【用實現類，由於要調用銷燬的方法】 System.out.println("-----容器建立前-----"); ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("com/eggtwo/test/applicationContext.xml"); System.out.println("-----容器建立完成-----"); // 從容器中獲取bean Student student1 = (Student) ac.getBean("student"); Student student2 = (Student) ac.getBean("student"); System.out.println(student1); System.out.println(student2); // 銷燬容器對象 ac.destroy(); } }
2.spring IOC容器的配置
1.對象的建立方式
SpringIOC容器，是spring核心內容。
做用： 建立對象 & 處理對象的依賴關係
IOC容器建立對象：
建立對象, 有幾種方式：
1） 調用無參數構造器
2） 帶參數構造器
3） 工廠建立對象
工廠類，靜態方法建立對象
工廠類，非靜態方法建立對象
<!-- ###############對象建立############### --> <!-- 1. 默認無參數構造器 <bean id="user1" class="cn.itcast.b_create_obj.User"></bean> --> <!-- 2. 帶參數構造器 --> <bean id="user2" class="cn.itcast.b_create_obj.User"> <constructor-arg index="0" type="int" value="100"></constructor-arg> <constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg> </bean> <!-- 定義一個字符串，值是"Jack" ; String s = new String("jack")--> <bean id="str" class="java.lang.String"> <constructor-arg value="Jacks"></constructor-arg> </bean> <bean id="user3" class="cn.itcast.b_create_obj.User"> <constructor-arg index="0" type="int" value="100"></constructor-arg> <constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg> </bean> <!-- 3. 工廠類建立對象 --> <!-- # 3.1 工廠類，實例方法 --> <!-- 先建立工廠 --> <bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean> <!-- 在建立user對象，用factory方的實例方法 --> <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean> <!-- # 3.2 工廠類： 靜態方法 --> <!-- class 指定的就是工廠類型 factory-method 必定是工廠裏面的「靜態方法」 --> <bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
2.對象的依賴關係
Spring中，如何給對象的屬性賦值? 【DI, 依賴注入】
1) 經過構造函數
2) 經過set方法給屬性注入值
3) p名稱空間
4)自動裝配(瞭解)
5) 註解
<bean id="userDao" class="com.eggtwo.dao.UserDao" ></bean> <bean id="userService" class="com.eggtwo.service.UserService"> <property name="userDao" ref="userDao"></property> </bean> <bean id="userAction" class="com.eggtwo.action.UserAction"> <property name="userService" ref="userService"></property> </bean>
3.spring和strut結合
步驟：
引入jar文件
1）引入struts .jar相關文件
2）spring-core 相關jar文件
3）spring-web 支持jar包
spring-web-3.2.5.RELEASE.jar 【Spring源碼】
struts2-spring-plugin-2.3.4.1.jar 【Struts源碼】
配置:
4）配置XML
web.xml
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <!-- 引入struts核心過濾器 --> <filter> <filter-name>struts2</filter-name> <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class> </filter> <filter-mapping> <filter-name>struts2</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <!-- 2. spring 配置 --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/classes/bean-*.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> </web-app>
bean.xml 【spring ioc容器配置】
每一個包配置一個bean
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <bean id="userService" class="com.eggtwo.service.UserService"> <property name="userDao" ref="userDao"></property> </bean> </beans>
struts.xml struts路徑與action映射配置】
注意：action交給了spring建立，再也不是tomcat建立
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd"> <struts> <!-- name任意名稱，extends:繼承的類 --> <package name="com.eggtwo.action" namespace="/" extends="struts-default" abstract="false"> <action name="execute" class="userAction" method="execute"> <!-- name:返回值， 跳轉地址 --> <result name="success" >/index.jsp</result> </action> </package> </struts>
【核心過濾器： 引入struts功能】
【初始化spring的ioc容器】
4.代理模式
靜態代理（JDK代理）
動態代理（JDK代理）
CgLib代理
5.Spring 註解實現AOP編程
AOP的實現本質上是代理（動態代理和Cglib代理）
注意：java jdk使用1.8版本，spring的jar包要使用4.2版本以上纔可使用AOP功能
開發步驟：
1.引入aop相關jar包
spring-aop-3.2.5.RELEASE.jar [spring3.2.5源碼/libs]
aopalliance.jar [spring-framework-2.5.6/lib/aopalliance]
aspectjrt.jar [aspectj-1.8.2/lib]
aspectjweaver.jar [aspectj-1.8.2/lib]
2.bean.xml中引入aop名稱空間
3.在bean.xml中開啓AOP註解模式
4.新建切面類
package com.eggtwo.aopanno; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; @Component //註解 ioc @Aspect //指定當前類爲切面類 public class MyAspect { @Pointcut("execution(* com.eggtwo.aopanno.UserDao.*(..))") public void myPointcut() { } //執行方法前執行 @Before("myPointcut()") public void begin() { System.out.println("開始執行"); } //執行目標方法後執行：（不管目標方法是否出現異常，都會執行） @After("myPointcut()") public void end() { System.out.println("結束執行"); } //執行目標方法後執行：（發生異常不執行） @AfterReturning("myPointcut()") public void afterReturning() { System.out.println("afterReturning"); } //執行目標方法後執行：（發生異常執行） @AfterThrowing("myPointcut()") public void afterThrowing() { System.out.println("afterThrowing"); } //環繞通知：環繞目標方法執行 @Around("myPointcut()") public void around(ProceedingJoinPoint pjp) throws Throwable { System.out.println("環繞前"); pjp.proceed(); System.out.println("環繞後"); } }
執行結果順序：
5.測試
package com.eggtwo.aopanno; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestApp { @Test public void test() { ApplicationContext ac = new ClassPathXmlApplicationContext("com/eggtwo/aopanno/bean.xml"); UserDao userDao = (UserDao) ac.getBean("userDao"); System.out.println(userDao.getClass()); userDao.save(); } }
6.Spring XML實現AOP編程
1.引入jar相關開發包（同步驟5.1）
2.引入命名空間（同5.2）
3.aop配置：添加切面類
package com.eggtwo.aopxml; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; public class MyAspect { //執行方法前執行 public void begin() { System.out.println("開始執行"); } //執行目標方法後執行：（不管目標方法是否出現異常，都會執行） public void end() { System.out.println("結束執行"); } //執行目標方法後執行：（發生異常不執行） public void afterReturning() { System.out.println("afterReturning"); } //執行目標方法後執行：（發生異常執行） public void afterThrowing() { System.out.println("afterThrowing"); } //環繞通知：環繞目標方法執行 public void around(ProceedingJoinPoint pjp) throws Throwable { System.out.println("環繞前"); pjp.proceed(); System.out.println("環繞後"); } }
4.配置bean.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd "> <!--spring IOC--> <bean id="userDao" class="com.eggtwo.aopxml.UserDao"></bean> <bean id="myAspect" class="com.eggtwo.aopxml.MyAspect"></bean> <!--AOP配置--> <aop:config> <!-- 定義切面點表達式：指定攔截的方法 --> <aop:pointcut id="myPointcut" expression="execution(* com.eggtwo.aopxml.UserDao.*(..))"/> <!-- 切面：引用上面配置的切面類--> <aop:aspect ref="myAspect"> <!--<aop:before method="begin" pointcut="execution(* com.eggtwo.aopxml.UserDao.*(..))"/>--> <aop:before method="begin" pointcut-ref="myPointcut"/> <aop:before method="end" pointcut-ref="myPointcut"/> </aop:aspect> </aop:config> </beans>
7.Spring 切入點表達式
做用：指定攔截的方法
8.Spring 事務管理
事務的實現自己是AOP
XML方式實現spring聲明式事務
SSH整合
1.引入jar包
Struts 核心jar
Hibernate 核心jar
Spring
Core 核心功能
Web 對web模塊支持
Aop aop支持
Orm 對hibernate支持
Jdbc/tx jdbc支持包、事務相關包
2.配置xml
*.hbm.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.eggtwo.entity"> <class name="Student" table="t_student"> <id name="id" column="id"> <generator class="native"></generator> </id> <!-- 外鍵映射：多對一 --> <many-to-one name="grade" column="gradeId" class="Grade"></many-to-one> <property name="name"></property> <property name="age"></property> <property name="birthday"></property> </class> </hibernate-mapping>
web.xml
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <!-- 配置spring的OpenSessionInView模式 【目的：JSp頁面訪問懶加載數據】 --> <!-- 注意：訪問struts時候須要帶上*.action後綴，這樣才能訪問懶加載數據 --> <filter> <filter-name>OpenSessionInView</filter-name> <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class> </filter> <filter-mapping> <filter-name>OpenSessionInView</filter-name> <!--url請求設置--> <url-pattern>*.action</url-pattern> </filter-mapping> <!-- struts2配置 --> <filter> <filter-name>struts2</filter-name> <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class> </filter> <filter-mapping> <filter-name>struts2</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <!-- Spring配置 --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:bean*.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <welcome-file-list> <welcome-file>index.jsp</welcome-file> </welcome-file-list> </web-app>
bean.xml
每個包中單獨一個bean
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 全部配置的公共部分 --> <!-- 1) 數據源對象: C3P0鏈接池實例 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql:///test"></property> <property name="user" value="root"></property> <property name="password" value="123456"></property> <property name="initialPoolSize" value="3"></property> <property name="maxPoolSize" value="6"></property> </bean> <!-- 2) SessionFactory實例建立 --> <!-- 全部的配置都由spring維護(項目中不須要hibernate.cfg.xml啦) --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <!-- a. 鏈接池 --> <property name="dataSource" ref="dataSource"></property> <!-- b. hibernate經常使用配置： 方言、顯示sql、自動建表等 --> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop> <prop key="hibernate.show_sql">true</prop> <prop key="hibernate.hbm2ddl.auto">update</prop> </props> </property> <!-- c. 映射配置 --> <property name="mappingLocations"> <list> <value>classpath:com/eggtwo/entity/*.hbm.xml</value> </list> </property> </bean> <!-- 3) 事務配置 --> <!-- # 事務管理器 --> <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> <!-- # 事務加強 --> <tx:advice id="txAdvice" transaction-manager="txManager"> <tx:attributes> <tx:method name="*" read-only="false"/> </tx:attributes> </tx:advice> <!-- # AOP配置 --> <aop:config> <aop:pointcut expression="execution(* com.eggtwo.service.*.*(..))" id="pt"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/> </aop:config> </beans>
struts.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd"> <struts> <package name="myAction" extends="struts-default"> <!-- action實例交給spring容器建立 --> <!--注意：action的class不能寫全稱類，要寫bean-action中的 bean id--> <!-- 這種寫法是把action交給tomcat建立，因此類要寫全稱 <action name="show" class="com.eggtwo.action.StudentAction" method="execute"> <result name="success">/index.jsp</result> </action> --> <action name="show" class="studentAction" method="execute"> <result name="success">/index.jsp</result> </action> </package> </struts>
3.開發
Entity/Dao/service/action
Entity
package com.eggtwo.entity; import java.util.Date; public class Student { private int id; // private int gradeId; private String name; private int age; private Date birthday; private boolean isMan; public Grade getGrade() { return grade; } public void setGrade(Grade grade) { this.grade = grade; } private Grade grade; public int getId() { return id; } public void setId(int id) { this.id = id; } // public int getGradeId() { // return gradeId; // } // // public void setGradeId(int gradeId) { // this.gradeId = gradeId; // } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Date getBirthday() { return birthday; } public void setBirthday(Date birthday) { this.birthday = birthday; } public boolean isMan() { return isMan; } public void setMan(boolean man) { isMan = man; } }
<?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>
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; } }
spring mvc
ssm=spring mvc+spring +mybatis
spring mvc工做流程
1A）客戶端發出http請求，只要請求形式符合web.xml文件中配置的*.action的話，就由DispatcherServlet來處理。
1B）DispatcherServlet再將http請求委託給映射器的對象來將http請求交給對應的Action來處理
2）映射器根據客戶的http請求，再對比<bean name="/hello.action若是匹配正確，再將http請求交給程序員寫的Action
3）執行Action中的業務方法，最終返回一個名叫ModelAndView的對象，其中封裝了向視圖發送的數據和視圖的邏輯名
4）ModelAndView對象隨着響應到到DispatcherServlet中了
5）這時DispatcherServlet收到了ModelAndView對象，它也不知道視圖邏輯名是何意，又得委託一個名叫視圖解析器的對象去具體解析ModelAndView對象中的內容
6）將視圖解析器解析後的內容，再次交由DispatcherServlet核心控制器，這時核心控制器再將請求轉發到具體的視圖頁面，取出數據，再顯示給用戶
XML實現spring mvc
開發步驟：
注意：使用的spring framework版本是：4.2.5
1.引入jar包：
spring核心包
commons-logging-1.1.3.jar
spring-beans-4.2.5.RELEASE.jar
spring-context-4.2.5.RELEASE.jar
spring-core-4.2.5.RELEASE.jar
spring-expression-4.2.5.RELEASE.jar
spring mvc包
spring-web-4.2.5.RELEASE.jar
spring-webmvc-4.2.5.RELEASE.jar
2.xml配置
web.xml配置
配置spring mvc核心控制器
解決提交表單中文亂碼
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <!-- 註冊springmvc核心控制器--> <servlet> <!--servlet-name的值對應一個文件：/WEB-INF/DispatcherServlet-servlet.xml --> <servlet-name>springmvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <!-- 指定application.xml文件 --> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc.xml</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>*.action</url-pattern> </servlet-mapping> <!--spring編碼過濾器：解決POST提交中文亂碼問題--> <filter> <filter-name>CharacterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <param-name>encoding</param-name> <param-value>utf-8</param-value> </init-param> </filter> <filter-mapping> <filter-name>CharacterEncodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> </web-app>
springmvc.xml配置
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/tx/spring-mvc.xsd "> <!-- 1.註冊Action(必須配置) --> <bean name="/hello.action" class="com.eggtwo.action.HelloController"></bean> <!--2.映射器：若是將bean標籤的name屬性值做爲請求URL.此標籤能夠省略--> <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean> <!--3.適配器：實現了Controller接口的適配器，默承認省略--> <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean> <!--4.視圖解析器--> <!-- 若是Action中書寫的是視圖邏輯名稱，那麼視圖解析器就必須配置 若是Action中書寫的是視圖真實名稱，那麼視圖解析器就不能配置 --> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <!-- 路徑前綴 --> <property name="prefix" value="/WEB-INF/jsp/"/> <!-- 路徑後綴 --> <property name="suffix" value=".jsp"/> <!-- 前綴+視圖邏輯名+後綴=真實路徑 --> </bean> </beans>
3.編寫Action
package com.eggtwo.action; import org.springframework.web.bind.annotation.InitBinder; import org.springframework.web.servlet.ModelAndView; import org.springframework.web.servlet.mvc.Controller; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.lang.annotation.Annotation; public class HelloController implements Controller { @Override public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception { ModelAndView modelAndView = new ModelAndView(); modelAndView.addObject("message", "這是個人第二個springmvc應用程序，視圖使用邏輯名"); //原來封裝視圖的真實路徑 // modelAndView.setViewName("/WEB-INF/jsp/success.jsp"); String name = request.getParameter("name");//獲取表單提交的數據 System.out.println("姓名:"+name); //如今封裝視圖的邏輯名稱 modelAndView.setViewName("success"); return modelAndView; } }
註解實現spring mvc
解決的問題：
1.一個controller中放置多個action
2.獲取get/post請求的參數(action接收的string類型的date參數怎麼轉成date)
3.限定action只能接收一種請求方式（get/post）
4.解決表單提交的中文亂碼
5.在action中獲取request/response
6.在action中重定向
7.action返回值類型（返回html、string、json、file等等）
8.在action中獲取request
1.引入jar包：
spring核心包
commons-logging-1.1.3.jar
spring-beans-4.2.5.RELEASE.jar
spring-context-4.2.5.RELEASE.jar
spring-core-4.2.5.RELEASE.jar
spring-expression-4.2.5.RELEASE.jar
spring aop包(註解會使用到aop)
aopalliance.jar
aspectjrt.jar
aspectjweaver.jar
spring-aop-4.2.5.RELEASE.jar
spring mvc包
spring-web-4.2.5.RELEASE.jar
spring-webmvc-4.2.5.RELEASE.jar
2.配置XML：
web.xml配置
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <!-- 註冊springmvc核心控制器--> <servlet> <!--servlet-name的值對應一個文件：/WEB-INF/DispatcherServlet-servlet.xml --> <servlet-name>springmvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <!-- 指定application.xml文件 --> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring_annotation.xml</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>*.action</url-pattern> </servlet-mapping> <!--spring編碼過濾器：解決POST提交中文亂碼問題--> <filter> <filter-name>CharacterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <param-name>encoding</param-name> <param-value>utf-8</param-value> </init-param> </filter> <filter-mapping> <filter-name>CharacterEncodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> </web-app>
spring mvc xml配置
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/tx/spring-mvc.xsd "> <!--讓spring ioc去掃描具體包下的全部具備註解@Controller的類--> <context:component-scan base-package="com.eggtwo.action"></context:component-scan> <!--註解映射器：可省略--> <bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"></bean> <!--視圖解析器--> <!-- 若是Action中書寫的是視圖邏輯名稱，那麼視圖解析器就必須配置 若是Action中書寫的是視圖真實名稱，那麼視圖解析器就不能配置 --> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <!-- 路徑前綴 --> <property name="prefix" value="/WEB-INF/jsp/"/> <!-- 路徑後綴 --> <property name="suffix" value=".jsp"/> <!-- 前綴+視圖邏輯名+後綴=真實路徑 --> </bean> </beans>
3.開發controller 和action：
package com.eggtwo.action; import com.eggtwo.entity.Student; import com.sun.org.apache.regexp.internal.RE; import org.springframework.beans.propertyeditors.CustomDateEditor; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.ServletRequestDataBinder; import org.springframework.web.bind.WebDataBinder; import org.springframework.web.bind.annotation.InitBinder; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.context.request.WebRequest; import javax.servlet.http.HttpServletRequest; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; /** * 此控制器是單例模式，構造函數只執行一次 * 註解控制器 */ @Controller @RequestMapping(value = "/anno") public class AnnotationController { public AnnotationController() { System.out.println("AnnotationController()"); } @RequestMapping(value = "/login.action") public String login(Model model) { model.addAttribute("message", "第一個註解實現的spring mvc login"); return "success";//邏輯名稱，須要配置視圖解析器 //return "/WEB-INF/jsp/success.jsp"; } /** * 設置請求的url,接收參數的方式，請求的方式（get/post）(默認get/post請求都支持) */ @RequestMapping(value = "/register1.action", method = {RequestMethod.POST, RequestMethod.GET}) public String register1(Model model, String name, int age, boolean man) { model.addAttribute("message", "註冊成功"); return "success"; // return "/WEB-INF/jsp/success.jsp"; } /** * 請求url中的.action能夠省略 */ @RequestMapping(value = "/register", method = RequestMethod.POST) public String register(Model model, Student student) { SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); System.out.println(student.getBirthday()); model.addAttribute("message", "註冊成功"); model.addAttribute("student", student); return "success"; // return "/WEB-INF/jsp/success.jsp"; } /** * 日期類型轉換器 * * @param binder */ @InitBinder public void initBinder(WebDataBinder binder) { //設置什麼類型的時間格式能夠轉 SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); dateFormat.setLenient(false); binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));//true:容許爲空, false:不容許爲空 } }
3.1action向view視圖(jsp頁面傳值)
@RequestMapping(value = "/register", method = RequestMethod.POST) public String register(Model model, Student student) { model.addAttribute("message", "註冊成功"); model.addAttribute("student", student); return "success"; }
3.2指定action加載返回的視圖（jsp頁面）
指定物理視圖名稱：
return "/WEB-INF/jsp/success.jsp";
指定邏輯視圖名稱：
return "success";
邏輯視圖須要在spring mvc文件配置視圖解析器
<!--視圖解析器--> <!-- 若是Action中書寫的是視圖邏輯名稱，那麼視圖解析器就必須配置 若是Action中書寫的是視圖真實名稱，那麼視圖解析器就不能配置 --> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <!-- 路徑前綴 --> <property name="prefix" value="/WEB-INF/jsp/"/> <!-- 路徑後綴 --> <property name="suffix" value=".jsp"/> <!-- 前綴+視圖邏輯名+後綴=真實路徑 --> </bean>
4.URL配置：
在controller和請求action上配置
@RequestMapping(value = "/anno")
5.請求方式配置：
@RequestMapping(value = "/register1.action", method = {RequestMethod.POST, RequestMethod.GET})
@RequestMapping(value = "/register", method = RequestMethod.POST)
若是不配置method，默認支持全部請求方式
6.請求參數接收：
1.變量直接接收：方法的變量名要和表單的name值保持一致，多用於get查詢請求
@RequestMapping(value = "/register1.action", method = {RequestMethod.POST, RequestMethod.GET}) public String register1(Model model, String name, int age, boolean man) { model.addAttribute("message", "註冊成功"); return "success"; // return "/WEB-INF/jsp/success.jsp"; }
2.模型綁定接收：方法的變量名要和表單的name值保持一致，能夠設置多個模型，多用於表單提交
@RequestMapping(value = "/register", method = RequestMethod.POST) public String register(Model model, Student student) { System.out.println(student.getBirthday()); model.addAttribute("message", "註冊成功"); model.addAttribute("student", student); return "success"; // return "/WEB-INF/jsp/success.jsp"; }
3.數組參數接收：批量刪除時用於接收ids，批量添加
ids爲checkbox的名稱
@RequestMapping(value = "/batchDelete.action") public String register(Model model, Integer[] ids) { for(int id :ids){ System.out.println(id); } return "success"; }
4.接收List<javaBean>集合
7.內部轉發和重定向
內部 轉發，url不變：可使用model在多個action中傳值，由於model是request域對象
@RequestMapping(value = "/forward.action") public String forward(Model model) { return "forward:/anno/login.action"; }
URL重定向，以url後綴的方式進行傳值
@RequestMapping(value = "/go.action") public String go(Model model) { return "redirect:/anno/login.action?id=3"; }
8.action返回json和字符串
第一步：導入json包
jackson-annotations-2.6.0-xh.jar
jackson-core-2.6.0-xh.jar
jackson-databind-2.6.0-xh.jar
jackson-jr-all-2.4.3-xh.jar
第二步：在action請求方法上使用@ResponseBody註解表示該方法的返回值放在響應體（Response Body）返回給用戶
第三步：在springmvc xml文件中配置json解析適配器
<!-- 註冊json解析適配器 --> <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> <property name="messageConverters"> <list> <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/> </list> </property> </bean>
第四步：開發action
返回json
@RequestMapping(value = "/getJson.action") @ResponseBody public Student getJson() { Student student = new Student(); student.setName("測試"); student.setMan(true); student.setBirthday(new Date()); student.setAge(14); student.setScore(12.254); return student; }
返回字符串
@RequestMapping(value = "/getString.action",method = RequestMethod.GET) @ResponseBody public String getString() { return "直接返回字符串"; }
9.在action中獲取當前請求的request
在controller中添加以下特性：能夠放在baseController
@Autowired protected HttpServletRequest request; //自動注入request
mybatis
1、 入門開發步驟
1.導入相關jar包
mybatis3.4.2核心開發包
asm-5.1.jar
cglib-3.2.4.jar
commons-logging-1.1.3.jar
log4j-1.2.17.jar
mybatis-3.4.2.jar
mysql驅動包
mysql-connector-java-5.1.7-bin.jar
2.定義實體及實體映射文件
定義member實體
package com.eggtwo.entity; import java.math.BigDecimal; import java.util.Date; public class Member { private int id; public int getId() { return id; } public void setId(int id) { this.id = id; } private String name; private int age; private Date birthday; private boolean man; private BigDecimal score; public BigDecimal getScore() { return score; } public void setScore(BigDecimal score) { this.score = score; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Date getBirthday() { return birthday; } public void setBirthday(Date birthday) { this.birthday = birthday; } public boolean isMan() { return man; } public void setMan(boolean man) { this.man = man; } }
定義MemberMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!--映射文件命名空間：要惟一--> <mapper namespace="memberDao"> <!-- *******當實體屬性和表字段名稱一致的話resultMap標籤能夠省略******** resultMap標籤：映射實體和表關係 id:映射關係id,要惟一 type:實體全路徑 --> <resultMap id="memberMap" type="com.eggtwo.entity.Member"> <!--id：映射主鍵屬性 result:映射非主鍵屬性 property:實體屬性名稱 column:表字段名稱 --> <id property="id" column="id"/> <result property="name" column="name"/> <result property="age" column="age"/> <result property="birthday" column="birthday"/> <result property="man" column="man"/> <result property="score" column="score"/> </resultMap> <insert id="add" parameterType="com.eggtwo.entity.Member" useGeneratedKeys="true" keyProperty="id"> insert into t_member(name,age,birthday,man,score) values(#{name},#{age},#{birthday},#{man},#{score}) </insert> <update id="update" parameterType="com.eggtwo.entity.Member"> update t_member set name = #{name}, age = #{age}, birthday = #{birthday}, man = #{man}, score = #{score} where id = #{id} </update> <delete id="delete" parameterType="int"> delete from t_member where id = #{id} </delete> <!-- <select id="getById" parameterType="int" resultType="com.eggtwo.entity.Member">--> <!--resultType使用mybatis.xml中設置的別名，這樣能夠簡化難度--> <select id="getById" parameterType="int" resultType="memberEntity"> select id,name,age,birthday,man,score from t_member where id=#{id} </select> <!-- 理論上resultType的值應該是:List<com.eggtwo.entity.Member> 實際上只須要寫List集合中的類型就能夠 --> <select id="getAll" resultType="com.eggtwo.entity.Member"> select * from t_member </select> <!--分頁：多參數的寫法--> <select id="getPageList" parameterType="map" resultType="com.eggtwo.entity.Member"> select id,name,age,birthday,man,score from t_member limit #{start},#{size} </select> </mapper>
3.定義mybatis.cfg.xml文件
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <!-- 加載類路徑下的屬性文件 --> <!--加載數據庫鏈接配置信息--> <properties resource="jdbc.properties"/> <!-- 設置類型別名 --> <typeAliases> <!--設置實體類Member的別名：memberEntity--> <typeAlias type="com.eggtwo.entity.Member" alias="memberEntity"/> </typeAliases> <!-- 設置一個默認的鏈接環境信息 --> <environments default="mysql_developer"> <!-- 鏈接環境信息，取一個任意惟一的名字 --> <environment id="mysql_developer"> <!-- mybatis使用jdbc事務管理方式 --> <transactionManager type="jdbc"/> <!-- mybatis使用鏈接池方式來獲取鏈接 --> <dataSource type="pooled"> <!--配置與數據庫交互的4個必要屬性 --> <!-- 直接配置方式，不推薦--> <!--<property name="driver" value="com.mysql.jdbc.Driver"/>--> <!-- <property name="url" value="jdbc:mysql://127.0.0.1:3306/test"/>--> <!--<property name="username" value="root"/>--> <!-- <property name="password" value="123456"/>--> <!--直接在jdbc.properties文件中配置鏈接--> <property name="driver" value="${mysql.driver}"/> <property name="url" value="${mysql.url}"/> <property name="username" value="${mysql.username}"/> <property name="password" value="${mysql.password}"/> </dataSource> </environment> </environments> <!-- 加載映射文件--> <mappers> <mapper resource="com/eggtwo/entity/MemberMapper.xml"/> </mappers> </configuration>
mybatis.cfg.xml加載的jdbc.properties文件
mysql.driver=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql://127.0.0.1:3306/test
mysql.username=root
mysql.password=123456
4.定義mybatis幫助類：MybatisUtil
package com.eggtwo.dao; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import java.io.IOException; import java.io.Reader; import java.sql.Connection; public class MybatisUtil { private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>(); private static SqlSessionFactory sqlSessionFactory; /** * 加載位於src/mybatis.xml配置文件 */ static{ try { Reader reader = Resources.getResourceAsReader("mybatis.cfg.xml"); sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); } catch (IOException e) { e.printStackTrace(); throw new RuntimeException(e); } } /** * 禁止外界經過new方法建立 */ private MybatisUtil(){} /** * 獲取SqlSession */ public static SqlSession getSqlSession(){ //從當前線程中獲取SqlSession對象 SqlSession sqlSession = threadLocal.get(); //若是SqlSession對象爲空 if(sqlSession == null){ //在SqlSessionFactory非空的狀況下，獲取SqlSession對象 sqlSession = sqlSessionFactory.openSession(); //將SqlSession對象與當前線程綁定在一塊兒 threadLocal.set(sqlSession); } //返回SqlSession對象 return sqlSession; } /** * 關閉SqlSession與當前線程分開 */ public static void closeSqlSession(){ //從當前線程中獲取SqlSession對象 SqlSession sqlSession = threadLocal.get(); //若是SqlSession對象非空 if(sqlSession != null){ //關閉SqlSession對象 sqlSession.close(); //分開當前線程與SqlSession對象的關係，目的是讓GC儘早回收 threadLocal.remove(); } } }
5.定義MemberDao測試mybatis增刪查改
6.測試
public static void main(String[] args) throws Exception { Connection conn = MybatisUtil.getSqlSession().getConnection(); System.out.println(conn != null ? "鏈接成功" : "鏈接失敗"); MemberDao memberDao = new MemberDao(); Member member = new Member(); member.setId(2); member.setAge(14); member.setName("張三1"); member.setBirthday(new Date()); member.setMan(true); member.setScore(new BigDecimal(123.24)); memberDao.add(member); // memberDao.update(member); // memberDao.delete(3); Member member1 = memberDao.getById(2); System.out.println(member1.getName()); List<Member> memberList = memberDao.getPageList(2,2); System.out.println("size:"+memberList.size()); for (Member m : memberList){ System.out.println(m.getId()); } }
2、 動態sql查詢
MybatisUtil
- 1. java WEB開發入門
- 2. java Web開發入門
- 3. Web開發入門
- 4. web開發 入門
- 5. Java Web開發入門 - 第3章 Tomcat
- 6. 【Java Web開發】XML快速入門
- 7. Web應用開發入門
- 8. Web App開發入門
- 9. python web 開發 - Django 入門
- 10. JAVA開發入門
- 更多相關文章...
- • Memcached入門教程 - NoSQL教程
- • Neo4j數據庫入門教程 - NoSQL教程
- • PHP開發工具
- • YAML 入門教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. java WEB開發入門
- 2. java Web開發入門
- 3. Web開發入門
- 4. web開發 入門
- 5. Java Web開發入門 - 第3章 Tomcat
- 6. 【Java Web開發】XML快速入門
- 7. Web應用開發入門
- 8. Web App開發入門
- 9. python web 開發 - Django 入門
- 10. JAVA開發入門