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模板来操做数据对象