JavaScript、SSH知識點整理

時間 2019-12-05

標籤 javascript ssh 知識整理欄目 JavaScript 简体版

原文原文鏈接

7、Javascript部分javascript

1：什麼是Javascriptcss

JavaScript是一種基於對象(Object)和事件驅動(Event Driven)並具備安全性能的腳本語言。html

2：Java和Javascript的差異java

1、基於對象和麪向對象node

Java是一種真正的面向對象的語言。即便是開發簡單的程序，必須設計對象。web

JavaScript是種腳本語言，它可以用來製做與網絡無關的，與用戶交互做用的複雜軟件。spring

它是一種基於對象（Object Based）和事件驅動（Event Driver）的編程語言。於是它自己提供了很豐富的內部對象供設計人員使用。 sql

2、解釋和編譯數據庫

兩種語言在其瀏覽器中所運行的方式不同。Java的源碼在傳遞到client運行以前，必須通過編譯，於是client上必須具備對應平臺上的仿真器或解釋器，它可以經過編譯器或解釋器實現獨立於某個特定的平臺編譯代碼的束縛。express

JavaScript是一種解釋性編程語言，其源碼在發往client運行以前不需通過編譯，而是將文本格式的字符代碼發送給客戶編由瀏覽器解釋運行。

3、強變量和弱變量

兩種語言所採取的變量是不同的。

Java採用強類型變量檢查，即所有變量在編譯以前必須做聲明。

JavaScript中變量聲明，採用其弱類型。即變量在使用前不需做聲明，而是解釋器在執行時檢查其數據類型，

4、代碼格式不同

Java是一種與HTML無關的格式。必須經過像HTML中引用外媒體那麼進行裝載，其代碼以字節代碼的形式保存在獨立的文檔中。

JavaScript的代碼是一種文本字符格式。可以直接嵌入HTML文檔中，並且可動態裝載。編寫HTML文檔就像編輯文本文件同樣方便。

5、嵌入方式不同

在HTML文檔中，兩種編程語言的標識不一樣，JavaScript使用<Script>...</Script>來標識，而Java使用<applet>...</applet>來標識。

6、靜態聯編和動態聯編

Java採用靜態聯編，即Java的對象引用必須在編譯時的進行，以使編譯器能夠實現強類型檢查。

JavaScript採用動態聯編。即JavaScript的對象引用在執行時進行檢查，如不經編譯則就沒法實現對象引用的檢查。

3：Javascript的執行環境

具有javascript執行器的

4：怎樣在web頁面增長Javascript，請寫出兩種方式並演示樣例

alert(11);

</script>

或者

5：寫出Javascript主要的數據類型

整型

實型

布爾

字符型

空值

特殊字符

6：Javascript中怎樣定義變量，有何規則

必須是一個有效的變量，即變量以字母開頭，中間可以出現數字如test1、text2等。除下劃線（－）做爲連字符外，變量名稱不能有空格、（＋）、（－）、（，）或其餘符號。

不能使用javascript中的keyword

可以用var聲明

7：代碼演示樣例：Javascript中的if控制語句的結構

if(i>4){

alert(11);

}

8：代碼演示樣例：Javascript中的for、while循環語句的結構

for(var i=0;i<10;i++){

alert(11);

}

while(i<10){

alert(22);

}

9：簡述break和continue的使用方法和功能

使用break語句使得循環從For或while中跳出，continue使得跳過循環內剩餘的語句而進入下一次循環。

10：Javascript中怎樣定義類，怎樣定義屬性。怎樣定義方法，請代碼演示樣例

function QuaryArgItem(){

this.keys = new Array();

this.values = new Array();

}

QuaryArgItem.prototype.push = function(key, value)

{

key = (key == null) ?

"" : "" + key;

value = (value == null) ? "" : "" + value;

this.keys.push(key.toUpperCase());

this.values.push(value);

}

QuaryArgItem是類名

push至關於方法名

使用的時候：

a = new QuaryArgItem();

a.push();

11：Javascript的function怎樣定義，有何規則

Function 方法名（參數,變元）{

方法體;

Return 表達式;

}

12：怎樣觸發Javascript的function

function test(){

alert(11);

}

13：說出下列String對象的方法的功能和使用方法：toLowerCase、indexOf、subString、toUpperCase

toLowerCase將指定字符串轉化爲小寫

indexOf推斷是否包括某一字符或字符串

subString從字符串中取一段並返回

toUpperCase將指定字符串轉化爲大寫

14：Javascript的日期對象是？怎樣初始化日期對象？

提供一個有關日期和時間的對象Date

date = new Date();

15：說出下列Javascript系統方法的功能和使用方法：eval、unEscape、escape、parseFloat

eval：返回字符串表達式中的值

unEscape：返回字符串ASCI碼

escape：返回字符的編碼

parseFloat：返回實數

16:：Javascript中怎樣定義數組？怎樣初始化？怎樣取值和賦值

var arrayName = new Array();

Function arrayName(size){

This.length=Size;

for(var x=; x<=size;x++){

this[x]=0;

}

Reture this;

}

17：簡要描寫敘述Javascript中下列內部對象的功能：Navigator、Window、Location、History、Document

Navagator：提供有關瀏覽器的信息

Window：Window對象處於對象層次的最頂層，它提供了處理Navagator窗體的方法和屬性

Location：提供了與當前打開的URL一塊兒工做的方法和屬性，是一個靜態的對象

History：提供了與歷史清單有關的信息

Document：包括與文檔元素一塊兒工做的對象，它將這些元素封裝起來供編程人員使用

18：怎樣利用Document來從頁面上取值和賦值

取值：var a = document.all("text1").value;

賦值：document.all("text1").value = '123';

19：簡要描寫敘述Javascript對象層次結構

window--document--組件

20：說出下列常見事件何時被觸發：onFocus、onBlur、onSelect、onChange、onClick

onBlur:當失去輸入焦點後產生該事件

onFocus:當輸入得到焦點後，產生該文件

Onchange:當文字值改變時，產生該事件

Onselect:當文字加亮後，產生該事件

onClick：當組件被點擊時產生的事件

21：代碼演示樣例：使用Frame做一個主要的三分頁面

<HTML>

<HEAD>

</HEAD>

</Frameset>

</HTML>

22：框架怎樣加載頁面

23：怎樣從框架中的一個頁面訪問還有一個頁面

var value = parent.right.document.all("text1");

CSS部分

1：怎樣把樣式表增長到html頁面中

在文檔<HEAD>中用<Style type="text/css"></style>定義；

使用<LINK>元素連接到外部的樣式表單。<LINK REL="stylesheet" href="style1.css">；

2：怎樣連接元素和樣式，請寫出4種方法，並代碼演示樣例

1、直接鏈接

2、class鏈接

3、id鏈接

4、元素的style=""

Xml讀寫演示樣例

package com.javawebv.addresslist.baseinfo.valueobject;

import java.io.*;

import java.util.*;

import javax.xml.parsers.*;

import javax.xml.transform.*;

import javax.xml.transform.dom.*;

import javax.xml.transform.stream.*;

import org.w3c.dom.*;

public class Fuxi{

public Fuxi(){}

public void runXml(){

File f = new File("f:/test/xmltest/student.xml");

try{

//首先建立一個documentbuilderfoctory的工廠

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

//利用工廠來建立documengbuilder

DocumentBuilder db = dbf.newDocumentBuilder();

//利用db的parse方法來解析xml文件

Document doc = db.parse(f);

//將讀出來的文件格式化

doc.normalize();

//定義一個nodelist數組來存放xml文件裏的節點（標籤）

NodeList students = doc.getElementsByTagName("student");

//從xml文件裏讀取數據

for(int i=0;i<students.getLength();i++){

//定義一個元素

Element student = (Element)students.item(i);

System.out.println("stu_id :"+student.getElementsByTagName("stu_id").item(0).getFirstChild().getNodeValue());

System.out.println("name :"+student.getElementsByTagName("name").item(0).getFirstChild().getNodeValue());

System.out.println("age :"+student.getElementsByTagName("age").item(0).getFirstChild().getNodeValue());

}

//向文件裏寫數據

String stu_id = "001";

String name = "xingxing";

String age = "22";

Text msg;

//建立元素

Element studentNew = doc.createElement("student");

//建立子元素

Element stuid = doc.createElement("stu_id");

//設置元素的值

msg = doc.createTextNode(stu_id);

//將值加入給元素

stuid.appendChild(msg);

//將元素加入到節點數組中

studentNew.appendChild(stuid);

Element name1 = doc.createElement("name");

msg = doc.createTextNode(name);

name1.appendChild(msg);

studentNew.appendChild(name1);

Element age1 = doc.createElement("age");

msg = doc.createTextNode(age);

age1.appendChild(msg);

studentNew.appendChild(age1);

//將元素studentnew加入到document樹中

doc.getDocumentElement().appendChild(studentNew);

//進行寫操做

TransformerFactory tff = TransformerFactory.newInstance();

Transformer tfor = tff.newTransformer();

DOMSource dos = new DOMSource(doc);

StreamResult result = new StreamResult(f);

tfor.transform(dos,result);

}catch(Exception e){

System.out.println(e.toString());

}

public static void main(String[] args){

Fuxi ff = new Fuxi();

ff.runXml();

}

8、 Struts

1、開發流程

1、建立表單

2、從表單中得到輸入

3、處理輸入（業務邏輯）

4、依據動態輸入改變輸入流

要完畢上述四步，咱們需要建立

1、一個ActionForm

2、一個action

3、一個配置文件struts-config.xml

4、建立頁面

建立actionform

1、寫一個類繼承actionform

2、私有的屬性

3、對應的get、set方法

4、重寫tostring、equals、hashcode三個方法

建立action

1、寫一個類繼承action

2、實現一個公有的方法（回調方法）

public ActionForward execute(ActionMapping mapping,

ActionForm form,

HttpServletRequest request,

HttpServletResponse response)

{

//1.收集參數

MyActionForm myForm = (MyActionForm)form;

//2.組織參數

//3.調用邏輯層

boolean flag = true;

//4.依據返回值來跳轉到對應的頁面

ActionForward af = new ActionForward();

if(flag){

af = mapping.findForward("1");

}else{

af = mapping.findForward("2");

}

return af;

}

配置struts-config.xml文件

1.<form-beans>

<form-bean name="myActionForm" type="全路徑.MyActionForm"/>

<form-bean />

</form-beans>

2.<action-mappings>

<action path="/sll"

name="myActionForm"

type="全路徑.MyAction"

scope="session"

input="錯誤返回的頁面">

</action>

</action-mappings>

步驟:

1.建立一個空的web應用

2.將struts的包放到lib目錄下

3.將.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟文件夾下

4.配置struts-config.xml文件和web.xml文件

5.在頁面引入tag文件uri

STRUTS執行機制

1、界面點擊產生請求

2、容器接到請求

3、匹配web.xml文件裏的*.do來生成actionservlet

4、actionservlet的處理

4.1 讀struts-congfig.xml文件造成actionmapping

4.2 經過path 來匹配Action類，經過action的name屬性來匹配actionform類

4.3 經過反射機制來給form添數據

4.4 由actionservlet轉調action的execute方法

4.5 獲得execute方法的返回值，跳轉頁面

4.5.1 RequestDispatcher

4.5.2 response.sendRedirect("list.jsp");

5、進入execute方法

5.1 收集參數

5.2 組織參數

5.3 調用，邏輯層

5.4 返回值

5.4.1 選擇下一個頁面（actionforward）

5.4.2 把值傳給下一個頁面（session）

9、在tomcat下配置數據源

1、server與數據庫的鏈接

配置server.xml文件

1.oracle

<Resource name="jdbc/company" scope="Shareable" auth="Container" type="javax.sql.DataSource"

factory="org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory"

url="jdbc:oracle:thin:@127.0.0.1:1521:eb"

driverClassName="oracle.jdbc.driver.OracleDriver"

username="sll"

password="sll"

maxActive="50"

maxIdle="10"

maxWait="-1"

2.sqlserver

<Resource name="jdbc/webpage" scope="Shareable" auth="Container" type="javax.sql.DataSource"

factory="org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory"

url="jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;

DatabaseName=webpagetest"

driverClassName="net.sourceforge.jtds.jdbc.Driver"

username="sa"

password=""

maxActive="50"

maxIdle="10"

maxWait="-1"

2、配置本身的web應用的xml文件

<Context path="/eb03web" docBase="F:/workweb/eb03web"

privileged="true" antiResourceLocking="false" antiJARLocking="false">

</Context>

3、配置web.xml文件

與server創建鏈接

<resource-ref>

<res-ref-name>jdbc/company</res-ref-name>

<res-type>javax.sql.DataSource</res-type>

<res-auth>Container</res-auth>

</resource-ref>

4、在應用程序中不直接與數據庫鏈接，經過DataSource鏈接池創建鏈接

//1.在程序單獨用時設置系統的屬性，在tomcat下可以不用配置。

System.setProperty(Context.PROVIDER_URL,"");

System.setProperty(Context.INITIAL_CONTEXT_FACTORY,"");

//2.建立一個上下文對象

InitialContext context = new InitialContext();

//3.經過上下文對象在鏈接池中查找DataSource

DataSource ds = (DataSource)context.lookUp("java:comp/env/jdbc/company");

//4.經過數據源創建鏈接

ds.getConnection();

10、ORM對象關係型數據庫映射

(Object Relation Mapping)

1、一個對象相應一個表（可以是多對多的關係）

1.對象的屬性的名稱和表字段的名稱可以不一樣

2.對象的屬性的數量和表字段的數量可以不一樣

3.類型可以不一樣。但數據類型之間可以轉換

二、有一個映射的描寫敘述文件————>xml

三、如何實現描寫敘述文件————>一段程序

對象映射（mapping）數據庫

id=11

name=cc ———— > (1) —————> tbl_user(id,name,age,tel,address)

age=25 <————(2) <————

(1)從對象映射到數據庫

1.JDBC

2.依據描寫敘述文件來動態拼接sql

3.運行。加入到數據庫中

(2)從數據庫中映射到對象

1.JDBC

2.拼接查詢sql

3.ResultSet

4.Model

11、Hibernate

hibernate 開發流程

1、是什麼？

hibernate是一種基於orm 的輕量級的框架

2、有什麼？

1.對外提供操做數據庫的接口

2.事務的處理

3.簡化數據持久化的編程任務

3、能幹什麼？

1.orm

2.提供操做數據庫的接口

4、怎麼作？

1.搭建hibernate的執行環境，將hibernate的包和hibernate所需要的包複製到lib 目錄下

2.O（vo）

3.R

4.配置文件

4.1 cfg.xml 放在classes根文件夾下。默認名字爲hibernate.cfg.xml

a.與數據庫的鏈接

b.可選配置

c.映射資源的註冊

4.2 hbm.xml文件名字與類名一樣並且與類放在一塊兒

a. 對象與數據庫表之間的映射

b. 對象的屬性與數據庫表的字段之間的映射

c.組件之間的映射

d.對象與對象之間的映射

5、client

1.獲得SessionFactory

2.經過SessionFactory 工廠來建立Session實例

3.打開事務

4.操做數據庫

5.事務提交

6.關閉鏈接

hibernate 執行流程

1、整體流程

1.經過configuration來讀cfg.xml文件

2.獲得SessionFactory 工廠（依據數據庫的鏈接來建立sessionfactory）

3.經過SessionFactory 工廠來建立Session實例

4.打開事務

5.經過session的api操做數據庫

6.事務提交

7.關閉鏈接

二、save

1.to--->po

2.根基model和cfg.xml中映射文件的註冊來找到hbm.xml文件

3.依據hbm.xml文件裏的unsave-value屬性來推斷是save仍是update

3.依據hbm.xml文件和model來動態的拼sql

4.client提交或者刷新內存

5.運行sql，值放到數據庫

3、update、delete

1.依據model 的id在內存hibernate的實例池中查找該對象

假設內存中沒有就到數據庫中查找來保證對象的存在

2.依據model和cfg.xml文件裏映射文件的註冊來找到hbm.xml文件

3.依據model和hbm.xml 文件來動態拼sql

4.client提交或者刷新內存

5.運行sql

4、Query

4.1 load

1.依據model的類型來找到hbm.xml文件

2.推斷id相應的對象是否存在

3.用id作爲查詢條件來動態拼sql

4.運行sql 查詢（先在內存中查找，假設沒有找到（會拋出例外），就去數

據庫中查找）

5.返回一個model類型的對象

4.2 get

4.運行sql 直接在數據庫中查找。假設沒有查到就會返回null

4.3

query

1.分析hql語句。獲得model的類型

2.依據moedel和cfg.xml文件裏映射文件的註冊找到hbm.xml文件

3.依據model和hbm.xml文件來動態拼sql

4.運行sql查詢數據庫

5.返回一個resultset

6.循環resultset的值，放到model中在放到集合中

12、spring

１. 是什麼？

Spring是基於JEE的輕量級的應用框架

２. 有什麼？

每個包的功能：

WEBMVC：spring 自己提供的web 框架

WEB：集成web 應用的框架

JEE ：繼承一系列的jee的技術

DAO：封裝了JDBC。

ORM：提供了對ＯＲＭ工具的集成

AOP ：面向切面編成

CORE：spring的核心包。提供bean的公廠和IOC容器

３. 能幹什麼？

把一列的jee的技術有效的組合在一塊兒造成以良好的系統

4．容器和bean

Bean ：是指受spring和ioc管理的對象稱爲bean

容器：（與jee的容器類比）

Jee ：提供組件的執行環境和管理組件的生命週期（不能單獨存在）

Spring ：提供bean的執行環境和管理bean的生命週期（可以單獨存在）

5．IOC控制反轉

從前的應用程序想要獲得A的實例他會直接主動的去拿，當用了sping後，應用程序由主動的去取變成被動的等待。由spring來控制應用程序所需要的對象

１. IOC的長處

1.可以經過IOC來得到實例

2.可以經過DI來獲取注入的資源

２. 配置IOC的原則

１. 必定是可變的資源才採用依賴注入

２. 必定是層間的接口或者是模塊之間的相互調用才採用依賴注入

３. 表現層調用邏輯層。可以讓表現層做爲client，而不要採用依賴注入。表現層僅僅需要邏輯層接口一個資源

6.DI依賴注入

1. 應用程序依賴spring注入所需要的對象

IOC和DI是對同一種事情的不一樣描寫敘述

2.setter注入：在配置文件裏將接口的實現配置爲bean在應用程序中注入bean

好比：

在配置文件裏

</bean>

在應用程序中

Public DBDAO dao ;

Public void setDao(DBDAO dao){

This.dao = dao;

}

3．構造器注入

<constructor-arg>

4．ref 表示參照其餘的bean

在參照的過程當中必定要注意死循環

5.本身主動裝配-----------〉no

本身主動裝配依據名字來匹配對應的bean 儘可能不要去本身主動裝配

6.lookup注入

7.singleton

1.單例模式是整個的jvm中僅僅有一個實例

2.spring的singleton是指在spring的容器中僅僅有一個實例

一個生命週期中僅僅有一個實例

8.DI的長處：

1.程序被動等待。強化面向接口編成

2.切斷了對象或組件之間的聯繫，使程序的結構更加鬆散，執行和

維護更加簡單

七、 Aop面向切面編程

1.AOP面向切面編程一些較好的模式或者是演示樣例----範式

切面：一個切面表明咱們所關注的一系列的共同的功能點（模塊之間的共同的功能點）

2.AOP的思想：主動---->被動（追加功能）

3.AOP 的概念

1.切面：咱們所關注的功能點

2.鏈接點：事件的觸發點（方法的運行）

3.通知：鏈接點觸發時運行的動做（方法）

4.切入點：一系列的鏈接點的集合（鏈接點的模塊化）

5.引入：擴展的功能

6.目標對象：包括鏈接點的對象

7.aop代理：實現機制

8.織入：把advice和目標對象鏈接起來

4.AOP的事件機制

1.經過切面找出一系列共同的功能點

2.找到目標對象(在標準的spring 中接口的實現類爲targer)

3.找到切入點

4.肯定鏈接點

5.經過動態織入點advice和鏈接點相應起來

6.動態織入由aop代理來實現

7.xml文件描寫敘述相應的關係

5.ascpet

5.1.在dtd中配置比較煩瑣

所有的入口必須從一個代理（ProxyFactoryBean）開始

<value>spring2test.aoptest.dtdv.Api</value>

</property>

</property>

</property>

<list>

<value>staticPointcut</value>

<value>staticPointcut2</value>

</list>

</property>

</bean>

5.2.配置切入點（RegexpMethodPointcutAdvisor）

<bean id="staticPointcut2"

class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

</property>

<list>

</list>

</property>

</bean>

id可以省去。由spring本身主動生成與類名一樣的名字

5.3.使用註解的方法相對簡單

@AspectJ的基本的語法

1.@Aspect聲明一個切面，將一系列的共同的功能定義成一個切面

直接在類上定義@Aspect

2.@Pointcut聲明切入點

2.1、用一個專門的類來定義pointcut，類中的方法名就是該pointcut的名字

2.2、可以使用匿名的pointcut

2.3、運行切點的幾種方法

2.3.1 execute（public * 包結構.*.*.（..））可以指定到詳細的方法

2.3.2 within 指定到包，不能指定到類

within（"com.javass.spring..*"）

2.3.3 this 指定到實現接口的所有的實現類

2.3.4 target 指定詳細的實現類

5.4.advice的五種類型的演示樣例

　　　 client必須從接口走才幹獲得監控，實現想要追加的功能　　　　　　

5.4.1.@AfterReturning(pointcut="" returning="retVal")

追加的方法的參數名字必定要與retrning的名字一樣

在註解@AfterReturning中必須加上pointcut和returning兩個參數

pointcut指所要監控的目標對象的方法

獲得目標對象的方法的返回值。來做爲參數，進行下一步的處理,參數沒有順序，按參數的名字進行匹配

完畢追加的功能

1 定義一個pointcut。經過方法名來做爲pointcut的名稱來引用

(1).@AfterReturning("com.javass.spring.schemaaop.TestPointcut.t4()")

(2).

2.直接引用匿名的pointcut

(1).@AfterReturning("execution(

* com.javass.spring.schemaaop.Api.test4())")

(2).@AfterReturning(pointcut=

"com.javass.spring.schemaaop.TestPointcut.t4() &&

args(str)", returning="retVal")

@AfterReturning (pointcut="com.javass.spring.schemaaop.TestPointcut.t4() && args(str)",returning="retVal")

public void testAfterReturning(String str,Object retVal){

System.out.println("afterReturning1=>"+retVal+"=>"+str);

}

5.4.2.@Aronud

註解@Around圍繞追加功能。

在運行目標對象的方法的前、後追加功能；

必須有參數。第一個參數的類型必須爲ProceedingJoinPoint；

經過ProceedingJoinPoint的實例的proceed來調用所監控的

目標對象的方法

1 定義一個pointcut。經過方法名來做爲pointcut的名稱來引用

(1).@Around("com.javass.spring.schemaaop.TestPointcut.t1()")

(2).@Around("com.javass.spring.schemaaop.TestPointcut.t2()

&& args(str)")

2.直接引用匿名的pointcut

(1).@Around("execution(

* com.javass.spring.schemaaop.Api.test1())")

(2).@Around("execution(

* com.javass.spring.schemaaop.Api.test2(..)) && args(str)")

// @Around("com.javass.spring.schemaaop.TestPointcut.t2() && args(str)")

@Around("execution(* com.javass.spring.schemaaop.Api.test2(..)) && args(str)")

public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{

System.out.println("around1==========before1pointcut==>"+str)

Object obj = prj.proceed();

System.out.println("around1==========after1pointcut==>"+str);

}

5.4.3.@Before

註解@Before在運行目標對象的方法前追加對應的功能

1 定義一個pointcut。經過方法名來做爲pointcut的名稱來引用

(1).@Before("com.javass.spring.schemaaop.TestPointcut.t1()")

(2).@Before("com.javass.spring.schemaaop.TestPointcut.t2() && args(str)")

注意args後的名稱與參數名一樣

2.直接引用匿名的pointcut

(1).@Before("execution(* com.javass.spring.schemaaop.Api.test1())")

(2).@Before("execution(* com.javass.spring.schemaaop.Api.test2(..)) && args(str)")

注意args後的名稱與參數名一樣

// @Before("com.javass.spring.schemaaop.TestPointcut.t2() && args(str)")

@Before("execution(* com.javass.spring.schemaaop.Api.test2(..)) && args(str)")

public void testBeforeParam(String str){

System.out.println("before1=param=>"+str);

}

5.4.4.@After

註解@After在運行目標對象的方法後追加對應的功能

1 定義一個pointcut。經過方法名來做爲pointcut的名稱來引用

(1).@After("com.javass.spring.schemaaop.TestPointcut.t1()")

2.直接引用匿名的pointcut

(1).@After("execution(* com.javass.spring.schemaaop.Api.test1())")

@After("com.javass.spring.schemaaop.TestPointcut.t1()")

public void testAfter(){

System.out.println("after1== >pointcut");

}

5.4.5.@AfterThorwing

6.@configurable

在配置文件裏需開啓 <aop:aspectj-configured/>

在根目錄下將一個META-INF目錄，在該目錄下建一個aop.xm文件由aop.xml文件用來定義切入點

這樣就可以在client直接new對象來直接操做（依賴注入是由aspectj來取代ioc）

設置執行時的參數 run --àArguments ---àVMarguments

在這裏並無直接用new出來的對象，而是經過aspectj依賴注入一個具備值的對象來取代他使用

7.中間數據層訪問事務：JDBC JTA（分佈式事務）

1. 聲明式事務管理：

1.流程：由client訪問----aop監控----調用advice來追加事務

2.作法：

2.1 在配置文件的頭中引入xmlns：tx 和schema的文件

2.2 <aop:aspectj-autoproxy/>

2.3 注入數據源

</bean>

2.4 由spring實現的事務管理，但需要注入數據源

</bean>

2.5 事務監控所有的方法

<tx:advice id="txAdvice" transaction-manager="txManager">

<tx:attributes>

<tx:method name="*"/>

</tx:attributes>

</tx:advice>

2.6 定義切入點

<aop:config>

<aop:pointcut id="my"

expression="execution(* com.javass.spring.schemaaop.Api.*.*(..))"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="my"/>

</aop:config>

2.7 在client經過DataSourceUtils.getConnection(dataSource)來得到

鏈接

2.8 咱們本身不要關閉鏈接

2編程式事務管理：

1.註解@Transcational

指哪打哪（可以在類上，也可以在方法上）

2.在配置文件裏相同需要注入dataSource和spring的事務管理

3.使用註解的方法來追加事務註解驅動

<tx:annotation-driven transaction-manager="txManager"/>

3. DAO的支持

1.JDBCTemplate

1.1、直接用來運行sql語句

2、ORM工具進行數據的訪問

2.1、Hibernate支持，集成hibernate

把在hibernate.cfg.xml中的配置搬到applicationcontext.xml中

<property name="dataSource" ref="dataSource"/>(鏈接數據庫)

<list>

<value>

com/javass/spring/schemaaop/UserModel.hbm.xml

</value>（資源註冊）

</list>

</property>

<property name="hibernateProperties">（可選配置）

<value>

hibernate.dialect=org.hibernate.dialect.Oracle9Dialect

hibernate.show_sql=true

</value>

</property>

</bean>

2.2、相同需要事務

</bean>

<aop:config>

<aop:pointcut id="my"

expression="execution(* com.javass.spring.schemaaop.Api.*.*(..))"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="my"/>

</aop:config>

<tx:advice id="txAdvice" transaction-manager="txManager">

<tx:attributes>

<tx:method name="*"/>

</tx:attributes>

</tx:advice>

3.hibernate模板和DAO支持都需要注入sessionFactory

4.在client繼承HibernateDaoSupport 來獲得hibernate模板

經過hibernate模板來操做數據對象

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。