首页 > 代码库 > JavaScript、SSH知识点整理
JavaScript、SSH知识点整理
七、Javascript部分
1：什么是Javascript
JavaScript是一种基于对象(Object)和事件驱动(Event Driven)并具有安全性能的脚本语言。
2：Java和Javascript的差别
1、基于对象和面向对象
Java是一种真正的面向对象的语言。即使是开发简单的程序，必须设计对象。
JavaScript是种脚本语言，它能够用来制作与网络无关的，与用户交互作用的复杂软件。
它是一种基于对象（Object Based）和事件驱动（Event Driver）的编程语言。因而它本身提供了很丰富的内部对象供设计人员使用。
2、解释和编译
两种语言在其浏览器中所运行的方式不一样。Java的源码在传递到client运行之前，必须经过编译，因而client上必须具有对应平台 上的仿真器或解释器，它能够通过编译器或解释器实现独立于某个特定的平台编译代码的束缚。
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，请写出两种方式并演示样例
<script language="javascript">
alert(11);
</script>
或者
<script language="javascript" src="http://www.mamicode.com/test.js"></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);
}
<input type="button" onClick="test();">
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 Rows="10%,90%">
<frame name="top" src="http://www.mamicode.com/test1.htm">
<Frameset Cols="40%,60%">
<frame name="left" src="http://www.mamicode.com/test2.htm">
<frame name="right" src="http://www.mamicode.com/test3.htm">
</Frameset>
</Frameset>
</HTML>
22：框架怎样加载页面
<frame name="left" src="http://www.mamicode.com/test.htm">
23：怎样从框架中的一个页面訪问还有一个页面
var value = parent.right.document.all("text1");
CSS部分
1：怎样把样式表增加到html页面中
在文档<HEAD>中用<Style type="text/css"></style>定义；
使用<LINK>元素链接到外部的样式表单。<LINK REL="stylesheet" href="http://www.mamicode.com/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();
}
}
八、 Struts
一、开发流程
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="错误返回的页面">
<forward name="1" path="/1.jsp">
<forward name="2" path="/2.jsp">
</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）
九、在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">
<ResourceLink global="jdbc/company" name="jdbc/company" type="javax.sql.DataSource"/>
</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();
十、ORM对象关系型数据库映射
(Object Relation Mapping)
一、一个对象相应一个表（能够是多对多的关系）
1.对象的属性的名称和表字段的名称能够不同
2.对象的属性的数量和表字段的数量能够不同
3.类型能够不同。但数据类型之间能够转换
二 、有一个映射的描写叙述文件————>xml
三 、如何实现描写叙述文件————>一段程序
对象 映射（mapping） 数据库
cc
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
十一、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.通过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，值放到数据库
三、update、delete
1.依据model 的id在内存hibernate的实例池中查找该对象
假设内存中没有就到数据库中查找来保证对象的存在
2.依据model和cfg.xml文件里映射文件的注冊来找到hbm.xml文件
3.依据model和hbm.xml 文件来动态拼sql
4.client提交或者刷新内存
5.运行sql
四、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中在放到集合中
十二、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 name=”dao” class=”daoImpl”>
<property name=”cc” ref=”cc”>
</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.切断了对象或组件之间的联系，使程序的结构更加松散，执行和
维护更加简单
7、 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）開始
<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>spring2test.aoptest.dtdv.Api</value>
</property>
<property name="target">
<ref local="B"/>
</property>
<property name="proxyTargetClass">
<value>true</value>
</property>
<property name="interceptorNames">
<list>
<value>staticPointcut</value>
<value>staticPointcut2</value>
</list>
</property>
</bean>
5.2.配置切入点 （RegexpMethodPointcutAdvisor）
<bean id="staticPointcut2"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref local="myBeforeAdvice"/>
</property>
<property name="patterns">
<list>
<value>.*t.*</value>
</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 id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="http://www.mamicode.com/oracle.jdbc.driver.OracleDriver"/>
<property name="url" value="http://www.mamicode.com/jdbc:oracle:thin:@127.0.0.1:1521:ccc"/>
<property name="username" value="http://www.mamicode.com/sll"/>
<property name="password" value="http://www.mamicode.com/sll"/>
</bean>
2.4 由spring实现的事务管理，但须要注入数据源
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</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中
<bean id="mySessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>(连接数据库)
<property name="mappingResources">
<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 id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="mySessionFactory"/>
</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模板来操作数据对象
JavaScript、SSH知识点整理