ssh

基础加强（反射）

枚举（了解）

私有化有参和无参的构造方法，用于多选一

enum Grade{

A("90-100"),B("80-90"),C("70-80"),D("60-70"),E("<60");

private String score;

private Grade(String score){

this.score=score;

}

public String toString() {

return "Grade [score=" + score + "]";

}

等同于在普通类里进行公有化的new对对象

public static Grade A = new Grade("90-100");

public static Grade B = new Grade("80-90");

public static Grade C = new Grade("70-80");

public static Grade D = new Grade("60-70");

public static Grade E = new Grade("<60");

反射（重点）

概念

java世界里的万物皆对象。

读取类的过程：由类加载器（ClassLoader)读取class字节码文件，把字节码文件的信息读取进内存，就会被构造成一个Class对象，利用Class对象去构造对象，调用方法，给属性赋值或获取属性值等等操作，这个过程就是反射！！

不通过new获取类对象

Class stu = Class.forName(输入完整包名); //推荐常用

Class stu = Student.class; 类名+class

Class stu = new Student().getClass();

Class对象，代表一个类

getName() //获取完整包名加类名

getSimpleName() //获取类名

getSuperClass() //得到普通父名

getGenericSuperClas() //得到泛型父名

getInterfaces() //得到普通类的接口名

getGenericIntefaces(); //得到泛型接口

getDeclaredConstructor(输入属性名可多个) //没输入就是得到无参，有输入就是得到有参

getDeclareMethod(输入get set方法，输入类型+class) //可以拿到get 、set方法

getDeclareField(输入成员属性名) //可以得到成员属性

Constructor对象：代表一个构造方法

newInstance() 获取构造对象

Method对象： 代表一个普通方法

invoke(obj,参数值) 调用方法

Filed对象：代表一个属性

set(obj,参数) 赋值

get(obj) 获取值

Type 对象：所有类型的公共高级接口

GenericArrayType 数组类型子接口

ParameterizedType 参数类型子接口（常用）

TypeVariable<D> 变量的子接口

WildcardType 通用的子接口

泛型

用处：把运行时异常转化为编译时异常，减少类型转换。

泛型语法

泛型方法（*）

public <T> T method(T t){

}

好处：为了写出通用方法

泛型类/泛型接口

public class Demo<T>{

}

好处：为了减少泛型方法的声明

?: 任意类型，为了保证泛型语法的完整性

extends: 当前类型或者当前类型的子类向下取

super: 当前类型或者当前类型的父类向上取

组合使用：(List<? super Number> list)

泛型+反射

getGenericSuperClass() //获取dao的泛型父列：BaseDao<Student>

应用：反射+泛型写出通用代码

//用于抽取业务dao的通用方法

//规则：表名称和类名保存一致（大小写不区别）

public class BaseDao<T> {

private Class targetClass;//需要封装的类型

private String tableName;//需要查询的表名称

//在BaseDao中如何接收泛型类?

public BaseDao(){

//System.out.println(this.getClass());// this: StudentDao 或者TeacherDao

Class clz = this.getClass();//当前运行的dao：StudentDao

Type type = clz.getGenericSuperclass();//获取dao的泛型父列：BaseDao<Student>

ParameterizedType pt = (ParameterizedType)type;//类型转换：转换成参数化类型的子类

Type[] tps = pt.getActualTypeArguments(); // 取出参数化类型的参数：<Student>

targetClass = (Class)tps[0]; // 取出第一个参数: Student.class

//表名

tableName = targetClass.getSimpleName().toLowerCase();

}

QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());

public List<T> findAll(){

try {

return qr.query("select * from "+tableName+"", new BeanListHandler(targetClass));

} catch (SQLException e) {

e.printStackTrace();

throw new RuntimeException(e);

}

public T findById(int id){

try {

return (T)qr.query("select * from "+tableName+" where id=?", new BeanHandler(targetClass),id);

} catch (SQLException e) {

e.printStackTrace();

throw new RuntimeException(e);

}

Struts2框架

struts2概念

struts2是一个基于MVC思想的表现层框架！！！

struts2的底层来源于另一个表现层框架webwork (xwork-core.jar)

struts2是struts1+webwork的整合框架

步骤1）struts2的jar包（最少）
commons-fileupload-1.3.1.jar 【上传组件】

commons-io-2.2.jar 【上传组件】

commons-lang3-3.2.jar 【字符串处理工具类】

freemarker-2.3.22.jar 【freemarker框架包】

javassist-3.11.0.GA.jar 【字节码处理工具类】

ognl-3.0.6.1.jar 【ognl表达式的支持包】

struts2-core-2.3.24.3.jar 【struts2自身的支持包】

xwork-core-2.3.24.3.jar 【wbeworkd框架的支持包】

步骤2）在web.xml中配置struts2的过滤类

org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter（在导入包中）

配置内容：

<web-app version="2.5"

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-app_2_5.xsd">

<display-name></display-name>

<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>

</web-app>

步骤3）写一个业务逻辑操作类

Public class XXXX(){

Public String xxx(){

（内容）

}

步骤4）写一个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">

继承包名需要加后缀分辨

<package name="（任意名字）" extends="struts-default" namespace="/"> //包名

可以用通配符*或*_*

<action name="(任取:路径访问名)" class="（完整包名）" method="(方法名)"> //类名

方法返回名一致可以多个方法

<result name="success" type="redirect">/index.jsp</result> //方法名

</action>

</package>

</struts>

Struts2执行流程

项目启动：

1）创建StrutsPrepareAndExecuteFilter核心过滤器对象

2）调用StrutsPrepareAndExecuteFilter的init方法

init_DefaultProperties(); 读取default.properties (常量文件）

（or/apache/struts2/default.properties）

init_TraditionalXmlConfigurations() 读取struts的核心xml配置文件

struts-default.xml struts2的默认配置文件（业务功能的声明）

struts-plugin.xml struts2的插件配置文件

**struts.xml** struts2的核心流程的配置文件（自行修改的）

每次发出请求（访问资源）：

1）调用StrutsPrepareAndExecuteFilter的doFilter方法

2）根据用户的请求uri在struts.xml文件的内容匹配对应的action

3）创建一个action配置的class的类对象（Action类对象）

4）调用Action类对象的指定的method方法

5）返回一个视图的字符串

6）根据视图的字符串查找匹配的result

7）跳转到具体的result的路径

解读struts-default.xml

业务功能声明文件

<result-types>

常用的视图类型：

dispatcher：转发页面

redirect：重定向页面

chain：转发到Action

redirectAction：重定向到Action （内容写另一个Action的name属性）

stream：用于文件下载的

</result-types>

拦截器（重要的概念）

在struts.xml配置中如何引用拦截器

<interceptor-ref name="(打包拦截器名)"></interceptor-ref> //引用打包后的拦截器

<result>/uploe.jsp</result>

</action>

//全局使用拦截器

<default-interceptor-ref name="(打包拦截器名)"></default-interceptor-ref>

拦截器效果类似于过滤器

拦截器 vs 过滤器

过滤器：是servlet的组件，用于过滤请求和响应

拦截器：是struts2的组件，只能用于拦截action

-->

com.opensymphony.xwork2.interceptor.ParametersInterceptor：参数拦截器

org.apache.struts2.interceptor.FileUploadInterceptor:文件上传拦截器

com.opensymphony.xwork2.interceptor.I18nInterceptor：国际化拦截器

.......

</interceptors>

创建拦截器类一个普通类继承MethodFilterInterceptor也可以继承AbstractInterceptor类

public class HelloInterceptor extends MethodFilterInterceptor{

//执行业务逻辑方法：doIntercept类似Filter的doFilter方法

//ActionInvocation类似Filter的FilterChain

@Override

protected String doIntercept(ActionInvocation invocation) throws Exception {

System.out.println("1.执行拦截器的前面代码");

/**

* 放行:

* 调用下一个拦截器，或者是目标的action

invocation.invoke();

System.out.println("3.执行拦截器的后面代码");

return null;

}

Struts.xml中配置拦截器（在package包中）

<interceptor name="(自定义拦截器的名字)" class="(完整包名)"></interceptor> //引用拦截器

<interceptor-stack name="(输入任意拦截器名字)"> //相当于打包拦截器

<interceptor-stackname="defaultStack"></interceptor-ref> //默认18个拦截器

<interceptor-ref name="(与自定义拦截器名字一致才能使用)"></interceptor-ref>

</interceptor-stack>

Struts2常量配置

Struts2项目启动时加载default.properties常量文件
struts.i18n.encoding： struts2项目中设置的编码

请求：request.setCharacterEncoding("utf-8")

响应： response.setContentType("text/html;charset=utf-8");

struts.multipart.parser： struts2使用的上传组件（默认jakarta:commons-fileUpload)

struts.multipart.saveDir: 文件上传时缓存目录

struts.multipart.maxSize：文件上传文件当前请求最大值

struts.action.extension struts2的action访问后缀配置

struts.devMode 是否打印对象信息

struts.enable.DynamicMethodInvocation：是否开启struts2的动态方法调用机制（默认关闭）

动态方法调用机制，用来简化action的配置，可以使用一个action配置来实现多个方法的调用注意：struts2不推荐开启，因为存在一定的安全漏洞！测试代码的时候可以开启使用！

修改（覆盖）struts常量

在struts.xml配置文件中添加

<constant name="struts.ui.theme" value="simple"></constant> //设置为简单模式把全部el表达式替代成ognl表达式

配置全局视图（包里面，action外面）对当前包下面的所有action起作用的

<global-results>

</global-results>

Acation读取参数

1：在方法内私有化需要接收的数据提供get和set的方法，相当于getParameter()方法

private String savePath;

public void setSavePath(String savePath) {

this.savePath = savePath;

}

2：在方法内私有化对象提供get和set方法，jsp页面数据前面必须带对象（常用）

用户名：<input type="text" name="type.name"></br>

密码：<input type="password" name="type.password"></br>

3：方法实现一个ModelDriven<对象名>接口，私有化对象必须new,然后让方法等于对象

private Type types=new Type();

@Override

public Type getModel() {

return types; （返回私有对象）

}

上传图片读取

表单的3 个必要条件

1：<input type="file" name="attach"/>

2：<form enctype="multipart/form-data" method="post"> //post提交重写enctype

在方法里写出以下私有方法接收，提供get和set方法

private String savePath; //文件传输的过去的地址

public String getSavePath() {

return savePath;

}

public void setSavePath(String savePath) {

this.savePath = savePath;

}

Struts.xml 配置

<param name="savePath">F:/金山打字通/</param> //需要复制过去的地址

//1.接收上传的文件

private File attach; //<input type="file/>的name属性名称

//2.接收文件类型

private String attachContentType; //名称：name属性+ContentType

//3.接收文件名称

private String attachFileName; //名称：name属性+FileName

文件上传细节配置

<interceptor-ref name="fileUpload"> //默认的不能写错

<param name="allowedTypes">image/jpeg,image/x-png,image/bmp</param>

</interceptor-ref>

下载文件

Struts.xml中如何配置文件(下载文件全部为配置)

<param name="contentType">application/octet-stream(全部格式)</param>

<param name="contentDisposition">attachment;filename=${fileName}</param>

<param name="inputName">fileStream(getInput方法)</param>

</result>

</action>

Action中如何写方法

public class DownAction extends ActionSupport{

//private InputStream fileStream;

private String fileName;

//下载方法

public String down(){

//返回下载视图

return "down";

}

//给struts.xml的inputName配置

public InputStream getFileStream() throws Exception{

File file = new File("E:/图片/1-111119121254.jpg");

fileName = file.getName();

return new FileInputStream(file);

}

//通过getter方法把名称输出给struts.xml文件

public String getFileName() throws Exception{

return URLEncoder.encode(fileName,"utf-8"); //如果图片有中文名字

}

国际化（了解）及自定义异常

struts2国际化

原理

com.opensymphony.xwork2.interceptor.I18nInterceptor 国际化拦截器

步骤：

在struts.xml文件中配置国际化资源文件的路径

在jsp页面使用struts2标签引用国际化文件内容

jsp页面使用： <s:text name="user"/>

action使用： getText("key") (注意:前提Action继承ActionSupport)

自定义异常

包名只能用点

在struts.xml中“input”是报错配置

<result name="input">/actionList.jsp</result>

传输数据给页面

1：使用原生的域对象进行共享

request,session,application

//得到域对象

HttpServletRequest request = ServletActionContext.getRequest();

HttpSession session = request.getSession();

ServletContext application = ServletActionContext.getServletContext();

2：使用三种Map集合共享数据

RequestMap：重新封装了HttpServletRequest

SessionMap: 重新封装了HttpSession

ApplicationMap: 重新封装了ServletContext

ActionContext类：工具类

//先得到ActionContext对象

//RequestMap

ActionContext ac = ActionContext.getContext();

Map requestMap = (Map)ac.get("request");

requestMap.put("r_prods", prods);

//System.out.println(requestMap.getClass());

//SessionMap

Map sessionMap = ac.getSession();

sessionMap.put("s_prods", prods);

//ApplicationMap

Map applicationMap = ac.getApplication();

applicationMap.put("a_prods", prods);

3：通过实现接口的方法使用三种Map集合（推荐）

私有化3个map<String,Object>参数

在Action类上面实现三个接口

RequestAware, SessionAware, ApplicationAware

写出get 和set方法

public class BaseAction extends ActionSupport implements RequestAware,SessionAware,ApplicationAware{

public Map<String, Object> requestMap;

public Map<String, Object> sessionMap;

public Map<String, Object> applicationMap;

值栈和ognl表达式

值栈

Struts2改变servlet+jsp层：

Action -> 把数据保存到*值栈* -> jsp -> 使用struts2标签+ognl表达式

值栈是struts2存取数据的核心

值栈是一个对象，这个对象实现接口 ValueStack

实现类：OgnlValueStack

值栈分为两个部分：

1：对象栈（Object Stack): ArrayList集合

作用：存放struts2运行过程的action对象，国际化对象.....

2：映射栈（Context (Map) Stack): HashMap集合

作用：存在struts2运行过程的固定的映射数据

存放的映射数据：

key value

===============================

request RequestMap对象（封装request域对象）

session SessionMap对象（封装session域对象）

application ApplicationMap对象（封装context域对象）

parameters ParametersMap对象（封装用户参数数据）

attr AttributeMap对象（封装三个Map集合）

（request : RequestMap

session: SessionMap

application: ApplicationMap）

获取值栈：

struts2框架在运行每个Action的方法前都会创建一个值栈对象。把这个值栈对象放入ActionContext对象中。

运行Action的方法 -> 创建值栈对象 -> 放入到ActionContext对象中 -> 执行代码

ActionContext ac = ActionContext.getContext();

ValueStack vs = ac.getValueStack(); //获取值栈

操作值栈

push(Object o) :压栈

pop(): 推栈

往Action添加一个属性：提供一个getter方法

操作映射栈

ValueStack.getContext().put("key",Object) 往映射栈添加一个元素

操作requestMap

Map rm = (Map)ac.get("request");

rm.put("rm", p);

//2.3 往session元素（SessionMap）添加一个元素

Map sm = ac.getSession();

sm.put("sm", p);

//2.4 往application元素（ApplicationMap)添加一个元素

Map am = ac.getApplication();

am.put("am", p);

ognl表达式

ognl表达式需要借助struts标签：<s:property value="ognl表达式"/>

取对象栈： 不带#号的ognl表达式

查询对象栈的对象顺序：

从栈的指定元素位置开始查询对应，直到栈底（最后一个元素）为止，把所有元素返回。

取某个对象： [0] (取对象栈的第一个元素后面的元素)

取某个对象的属性：[0].name (注意:查询getName()方法)

name 默认就是从第一个元素开始查属性

取映射栈： 带#号的ognl表达式

取映射栈的request的元素：#request.product

取映射栈的session的元素：#session.product

取映射栈的application的元素：#application.product

取映射栈的paraemters的元素：#parameters.product

取映射栈的attr的元素：

#attr.request

#attr.session

#attr.application

Struts标签

Struts逻辑标签

数据标签：

<s:set/> 赋值到值栈中

<s:property/> 从值栈获取数据

条件判断：

<s:if>

<s:elseif>

<s:else>

循环：

<s:iterator> //类似迭代器

Ui类标签

用于简化页面的html输出

表单标签：

<s:form>

<s:textfield/> //就是input输入框 type=”text”

<s:password/> //类似input输入密码type=”password”

<s:radio/>

<s:checkbox/> //存单个的多选框

//可以存集合的多选框(以Map集合存储进去，id键，对象为值)

<s:checkbostlist list="#request.types" name="types" listKey="key" listValue="value.name" value="curTypes"/>

//下拉框

<s:select list="#request.types" listKey="key" listValue="value.name" value="curTypes"/>

Action传输内容

private List curTypes;

public List getCurTypes() {

curTypes = new ArrayList();

curTypes.add(2);

curTypes.add(3);

return curTypes;

}

public void setCurTypes(List curTypes) {

this.curTypes = curTypes;

}

//查询

public String query(){

Map<Integer,Types> types = new HashMap<Integer,Types>();

types.put(1,new Types(1,"图书类"));

types.put(2,new Types(2,"男装"));

types.put(3,new Types(3,"电器类"));

requestMap.put("types", types);

return "tags";

}

表单验证

步骤：

(了解)方法1：Action必须继承actionSupport类，覆盖重写validate方法，里面验证信息和页面数据一致

方法2：配置

把一个验证文件（Action名称-validation.xml）放在对应Action的目录下

内容：

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE validators PUBLIC "-//Apache Struts//XWork Validator 1.0//EN" "http://struts.apache.org/dtds/xwork-validator-1.0.dtd">

<!-- struts2提供了一些常用的属性验证器

requiredstring：必须填写字符串

regex: 正则表达式

email: 邮箱格式验证器

-->

<field name="user.name"> //页面数据

<field-validator type="requiredstring">

<message>用户名必须填写2222</message> //input错误提示语句

</field-validator>

</field>

<field-validator type="regex">

<param name="regexExpression">[a-zA-Z0-9]{4,16}</param> //正则

<message>用户名格式有误：4-16位字母或者数字222</message>

</field-validator>

</field>

<field-validator type="requiredstring">

<message>邮箱必须填写2222</message>

</field-validator>

</field>

</validators>

注意

Xml配置文件的注意事项：

1）Action名称-validation.xml对Action的所有方法生效！

2）如果需要局部验证Action某个方法：Action名称-方法访问名-validation.xml

注意：如果有错误，则调用addFieldError放入错误信息，struts2会自动跳转到input视图

必须在struts.xml配置一个input的视图(否则报错)

*<result name="input">/user.jsp</result>*

</action>

Jsp:页面显示错误信息

<s:fielderror></s:fielderror>

Hibernate框架

Orm 思想（对象关系映射）

关系领域（关系型数据）对象领域（java）

一张表一个类

一个字段类的一个属性

一条记录一个类的对象

启动步骤

1：导包

1）hibernate的lib里面的required目录的10个jar

2）对应数据库的驱动程序*

2：编写hibernate的启动配置文件（包括数据库连接信息）

在src目录建立一个hibernate.cfg.xml

<?xml version="1.0" encoding="utf-8"?>

<!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://localhost:3306/day31?useUnicode=true&characterEncoding=utf-8</property>

<property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>

<mapping resource="gz/itcast/entity/Student.hbm.xml"/> //类似struts2配置

</session-factory>

</hibernate-configuration>

3：编写实体类javabean（必须有无参构造）

4：创建关系型映射文件(通常把对象.hbm.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="(包名)" 表名

<!-- 主键维护策略 :

assigned:程序分配id

-->

</id>

</class>

</hibernate-mapping>

5：代码部分(主要获取对象) 可以写一个hibernateUtil.java工具包

//1.获取Session对象

//1.1 加载hibernate.cfg.xml文件

Configuration config = new Configuration().configure();

//1.2 创建一个服务注册器（4.0新特性）

StandardServiceRegistry serviceRegistry =

new StandardServiceRegistryBuilder().applySettings(config.getProperties()).build();

//1.3 创建SessionFactory对象

SessionFactory sessionFactory =config.buildSessionFactory(serviceRegistry);

//1.4 获取一个Session

Session session = sessionFactory.openSession();

//注意：hibernate强制使用事务

//开启事务

session.getTransaction().begin();

执行操作xxxxx

//提交事务

session.getTransaction().commit();

//发生错误回滚事务 try /catch

session.getTransaction().rollback();

注意关闭资源

session.close();

sessionFactory.close();

hibernate.cfg.xml配置

<hibernate-configuration>

<session-factory> -- 连接一个数据库的项目信息

第一部分：连接参数

第二部分：hibernate环境参数

hibernate.dialect：数据库方言。为了hibernate适应不同的数据库，方便生成不同数据库例如：sql语句核心包： org.hibernate.dialect.MySQL5InnoDBDialect

hibernate.show_sql：是否显示执行sql语句（方便测试而已） //值：true

hibernate.format_sql：是否格式化sql语句（方便测试而已） //值：true

hbm2ddl.auto：是否需要hibernate维护数据库。默认不维护

值：create: 每次会自动创建表结构

值: update: 每次会更新（先对比）表结构

第三部分：对象关系映射文件

*.hbm.xml解读配置(核心)

第一种：配置文件注入

<hibernate-mapping>

package：类所在的包

<class> -- 代表需要映射一个类

name: 代表映射类名（如果没有配置package，必须写全名）

table: 代表需要映射到的表名

<id name="(实体ID)" column="(对应表单ID)"> 代表主键配置

<generator class="assigned"> 主键维护策略

<property name=”属性名称” column=”字段名称” length=”字段长度”> 代表普通属性映射

第二种：注解注入(常用)

Hibernate注解

概念：

hibernate注解是代替xml配置的另一个参数配置方案

步骤：

1：在实体类指定位置上指定注解

2：在hibernate.cfg.xml加入映射类 <mapping class="gz.itcast.b_annotation.Product(实体类)"/>

常见注解：

@Entity 声明当前类是一个映射类（如果需要映射的类必须加）

@Table(name="t_product", indexes={@Index(columnList="NAME", name="IDX_USER_NAME")}(增加索引值在查询时会比较快)) 声明表名 (可以省略不写，表与实体属性名一致)

@Table(name="OA_ID_USER(表名)", indexes={@Index(columnList="NAME", name="IDX_USER_NAME")})

@Id 声明主键

+@GeneratedValue(strategy=GenerationType.AUTO)(可以选择谁负责增长AUTO代表自动选择) 声明注解维护策略默认数据库生成id值

@Column(name="p_id",length=”指定字段长度”) 声明字段名

@OneToMany(cascade={CascadeType.ALL},mappedBy="user") 一对多

@ManyToOne(fetch=FetchType.LAZY(是否延迟加载,必须填), targetEntity=User.class(关联的实现化类)) 多对一

+@JoinColumn(name="MODIFIER(取外键列的列名)", referencedColumnName="USER_ID(引用主表的那个主键列名)", foreignKey=@ForeignKey(name="FK_DEPT_MODIFIER")(更改外键约束名，不写的话自动生成))

@JoinColumn(name="MODIFIER", referencedColumnName="USER_ID",

foreignKey=@ForeignKey(name="FK_DEPT_MODIFIER"))

@ManyToMany(fetch=FetchType.LAZY(懒加载), targetEntity=Role.class(需要引用的实习化类), mappedBy="users(中间表由角色来维护，没加代表自己维护)") 多对多

+@JoinTable(name="OA_ID_USER_ROLE(多对多需要生成外表，外表的名字)", joinColumns=@JoinColumn(name="ROLE_ID(没有加mappedBy的列名)", referencedColumnName="ID(需要关联的主键id)"), inverseJoinColumns=@JoinColumn(name="USER_ID(加了mappedBy的列名)", referencedColumnName="USER_ID(需要关联的主键id)"))

@JoinTable(name="OA_ID_USER_ROLE", joinColumns=@JoinColumn(name="ROLE_ID", referencedColumnName="ID"), inverseJoinColumns=@JoinColumn(name="USER_ID", referencedColumnName="USER_ID"))

@OneToOne 一对一

@Temporal(TemporalType.TIMESTAMP)指定数据库为时间格式，TIMESTAMP(年月日时分秒)

Session对象基本CRUD操作

1：保存save

session.save(放入存储的对象)

2：修改数据get拿set直接改

Product p = (Product)session.get(Product.class, 2); //对象.class和对应ID号

修改数据

p.setName("iphone6s");

3：查询get数据

Product p = (Product)session.get(Product.class, 1); //get一调用就执行

Product p = (Product)session.load(Product.class, 1); //调用不执行，需要才执行

Hql语句

List<Product> list = session.createQuery("from Product p").list();

for (Product product : list) {

System.out.println(product);}

4：删除delete

Product p = new Product();

p.setId(1);

session.delete(p);

方式二：（推荐）

Product p = (Product)session.get(Product.class, 1);

if(p!=null){

session.delete(p);

}

主键维护策略

开发者：

assigned 开发者自觉给

数据库：(类型必须是int或Integer)

identity 利用自增长策略，只能用在mysql或者sql server

sequence 利用序列增长策略，只能在oracle或者db2

*native （推荐）自动根据具体的数据库增长策略，选择最优的一个

hibernate：

*increment：hibernate的自增长策略（每次先查表的最大id值，然后+1）（int）

uuid： hibernate提供的uuid算法策略 (String)

hibernate.hbm.xml映射不同类型

type="integer"

hibernate类型 java类型

*整数 int/integer java.lang.Integer

*小数 double java.lang.Double

*字符 string java.lang.String

*日期 date java.util.Date

字符文件 text java.lang.String

字节文件 binary byte[]

集合映射

Set集合映射

<key column="uid"></key> //外键的id

<element column="address" type="string"></element> //string小写

</set>

List集合映射

</list>

Map集合映射

<map-key type="string" column="任意名"></map-key>

</map>

对象关系映射

一对多单向

例子

对象：这个对象有其他对象信息这个没有

class User{ class Address{

int id; int id;

String name; String name;

int age; String zipcode;

*Set<Address>* String phone;

String address;

}

Hibernate.hbm.xml配置映射

<one-to-many class="gz.itcast.c_one2many_single.Address(完整全名)" />//一对多关键语句

</set>

级联映射 在set里加个cascade="all " 全部自动更新

save-update: 当保存/更新会员(User)的数据时，同时保存/更新起关联的收货地址

delete : 当删除会员(User)的数据时，同时删除起关联的收货地址（Address)对象

all: save-update + delete

多对一单向

对象：这没有外面实体信息关联了外面实体信息

class User{ class Address{

int id; int id;

String name; String name;

int age; String zipcode;

String phone;

String address;

*User user;*

}

Hibernate.hbm.xml配置映射

<many-to-one name="实体名user" class="gz.itcast.many2one_single.User(完整包名)"

column="uid(另个实体id值)" cascade="all" (自动)></many-to-one>

一对多及多对多双向

一对多（多对一）双向

<one-to-many class="gz.itcast.a_many2one_double.Address(对多的对象)"/>

</set>

<!-- 多对一配置

column: 值和一对多的key保持一致！！

-->

<many-to-one name="user(一对多的对象)"

class="gz.itcast.a_many2one_double.User(对一的对象)"

column="uid(一对多的Key值)"

cascade="all"/>

多对多双向（相当于重新建立一个关系表）

inverse: 是否需要反转关系的维护权

false: 不反转，由当前方维护

true:需要反转，由对方维护

hibernate在一对多的关心中，默认由一方维护（inserse="false"）,为了提高效率（节省了update语句），可以把一方的insevse设置为true，把维护权给多方。

Student表

<!-- set元素

class: set集合的元素的类型

column: set元素的表在关系表的外键

-->

<many-to-many class="gz.itcast.b_many2many_double.Teacher(关联的表)" column="tid(关联表的key值)"></many-to-many>

</set>

Teacher表

<many-to-many class="gz.itcast.b_many2many_double.Student(关联的表)" column="sid(关联表的key值)"></many-to-many>

</set>

一对一双向

<!-- 一对一的主键关联配置：一对一配置

constrained: 是否把主键设置为外键

false:否

true: 是

-->

例如：一人对一身份证

<one-to-one name="idcard"

class="gz.itcast.c_one2one_double.IdCard"

cascade="all"/>

<!-- 一对一的主键关联配置：一对一配置

constrained: 是否把主键设置为外键

false:否

true: 是

-->

<one-to-one

name="person"

class="gz.itcast.c_one2one_double.Person"

constrained="true"></one-to-one>

hibernate查询(hql语句)

全表查询返回list集合 from (对象名)

指定字段查询 默认情况下,返回一个List<Object[]>需要遍历两次才能拿数据，可以封装成List<Employee>，在Employee里有参构造(有参的值写需要返回封装的对象属性)

select e.(对象属性),e.(对象属性) from (对象名) e(自定义别名)

条件查询返回list

from (对象名) e(自定义别名) where e.(对象属性)=? and e.(对象属性)=?

设置属性？

q.setParameter(0, "李_");

q.setParameter(1, 6500.0);

from (对象名) e(自定义别名) where e.(对象属性) like ? //like模糊查询

q.setParameter(0, "%李%"); //%表示省略前后

查询排序返回list 排序： order by asc: 升序 desc : 降序

from (对象名) e(自定义别名) order by e.(对象属性) asc

聚合查询返回一个对象（max,min avg,count...）

select max(e.对象属性) from (对象名) e(自定义别名)

统计查询可以设置约束条件（变成分页查询）返回int值

select count(e) from (对象名) e(自定义别名)

设置分页

q.setFirstResult(0); //起始位置

q.setMaxResults(3); //查询条数

分组查询 (group by)

select e.(对象属性1),count(*) from (对象名) e(自定义对象别名) where e.(对象属性1) is not null and e.(对象属性1)<>'' group by e.(对象属性1)

分组后筛选(having)

select e.(对象属性1),count(*) from (对象名) e(自定义对象别名) where e.(对象属性1) is not null and e.(对象属性1)<>'' group by e.(对象属性1) having count(*)>2(条件)

多表查询 内连接(inner join) 外右连接(right outer join)

(内连接)select e.name,e.dept.deptName from (对象名) e(自定义对象别名) inner join e.dept

(外右连接) select e.dept.deptName,e.name from (对象名) e(自定义对象别名) right outer join e.dept

原生sql查询

SQLQuery sq = session.createSQLQuery("select * from employee"); //原来sql语句表名

//封装成什么对象

sq.addEntity(Employee.class);

List<Employee> list = sq.list();

注意：如果该查询需要比较高的性能要求，可以使用sql查询

细节

一级缓存

概念

一级缓存，也称之为Session级别的缓存，在Session对象内部设计的一个缓存，只能在Session范围内使用。

默认情况下，一级缓存是打开和使用，我们不能关闭它。

操作一级缓存

1：session.flush() 同步一级缓存的数据 (经常跟第3一起用,刷完内存里东西,然后删除内存对象)

2：session.evict(obj) 从一级缓存清除某个对象

3：session.clear() 清空一级缓存的所有对象

Hibernate对象状态

临时状态

例如： Student stu=new Student() 新new对象

不在一级缓存中

数据库找不到对应记录

持久对象

例如：Admin admin = session.get(Admin.class, 1); 从session中直接取出来的数据

在一级对象中

数据库找得到对应记录

游离对象

例如：Student s = (Student) session.get(Student.class, 1); // s:持久对象 session.evict(s);//删除一级缓存里的数据

不在一级缓存中

游离对象的数据和数据库的数据保持一致，但是不能用于任何修改操作

删除对象

例如：Student s = (Student) session.get(Student.class, 3); // s:持久对象 session.delete(s);

不在一级缓存中

数据库数据不一致

延迟加载

get和load的区别

get

(1)Get方法执行后立即查询数据库数据，返回数据库数据(真实对象)

(2)get方法如果查询数据库没有对应数据时，返回null

Load

(1) load方法执行之后，没有查询数据库(返回的是一个代理对象)，而是在使用对象的属性数据

(2) load方法如果查询数据库没有对应数据时，返回ObjectNotFound异常

延迟加载

<one-to-many class="gz.itcast.d_lazy.Address"/>

</set>

二级缓存

步骤1：导入二级缓存的jar包

ehcache-core-2.4.3.jar

hibernate-ehcache-4.3.8.Final.jar

slf4j-api-1.7.2.jar

slf4j-log4j12-1.7.2.jar

步骤2：配置开启二级缓存(hibernate.cfg.xml).

<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

<mapping xxxx/> //需要引用的二级缓存必须放在mapping后面

（可以使用注解在实体类上写入@Cache(usage=CacheConcurrencyStrategy.READ_WRITE)）

<class-cache usage="read-write" region="itCache" class="gz.itcast.d_lazy.Address(需要二级缓存的实体)"/>

步骤3：提供配置文件.

src/ehcache.xml

配置查询缓存(效果不大)

-- 提高查询速度.(二级缓存的基础之上).

缓存的是查询语句.

-- 配置开启查询缓存(hibernate.cfg.xml).

-- 指定哪些查询语句做缓存.

getSession().createQuery(hql).setCacheable(true);

连接池插件(c3p0)

1: 导入c3p0插件包 optional\ehcache\(hibernate的lib包中)

c3p0-0.9.2.1.jar

hibernate-c3p0-4.3.8.Final.jar

mchange-commons-java-0.2.3.4.jar

2: 在hibernate.cfg.xml配置

<property name="hibernate.connection.provider_class">org.hibernate.c3p0.internal.C3P0ConnectionProvider</property>

<property name="connection.url">jdbc:mysql://localhost:3306/day34?useUnicode=true&characterEncoding=utf-8</property>

<property name="connection.driver_class">com.mysql.jdbc.Driver</property>

Spring框架

概念

spring是一个JavaEE应用程序的一站式（full-stack)框架,是一个轻量级的*IOC*和*AOP*的容器框架,主要用于解决应用中javabean对象的生命周期管理和对象之间的依赖关系问题，还可以整合其他如struts2,hibernate等框架，简化这些框架的使用。

Spring的 IOC

设计一个beanFactory（实例工厂）解决项目管理问题

Spring IOC开发步骤

1：导入jar包

commons-logging-1.1.1.jar

spring-beans-4.2.0.RELEASE.jar

spring-context-4.2.0.RELEASE.jar

spring-core-4.2.0.RELEASE.jar

spring-expression-4.2.0.RELEASE.jar

2：编写一个类

public class UserDao {

public void save(){

System.out.println("userDao.save()....");

}

3：在src目录里建立一个applicationContext.xml (或者beans.xml或者sprirng.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"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

4：获取对象

//使用类路径方式读取spring的xml文件

ApplicationContext ac =

new ClassPathXmlApplicationContext("/gz/itcast/a_hello/applicationContext.xml");

//2.从springIOC工厂中获取一个对象

UserDao userDao = (UserDao)ac.getBean("userDao");

等同于UserDao user =new UserDao

SpringIOC的简介

springIOC，主要解决的是对象管理问题，以及对象之间的依赖关系问题！！！！

IOC, Inversion Of Control 控制反转（解决对象创建问题）

没有IOC：new Student() 直接获取一个对象依赖性太强，耦合性太大

有IOC: getBean("xxx") 把对象的控制器托管给BeanFactory（springIOC）

DI,dependency injection 依赖注入（解决对象之间的依赖关系问题）

没有DI: IUserDao usrDao = new UserDao()

有DI: IUserDao userDao;

public void setUserDao(IUserDao userDao){

this.userDao = userDao;

}

对象创建问题(IOC)

使用无参构造方法创建对象

注意：

在给对象提供了有参的构造方法的同时，不要忘记补上一个无参构造方法

使用有参构造方法创建对象

<constructor-arg index="0" value="狗娃"></constructor-arg>

<constructor-arg index="1" value="20"></constructor-arg>

</bean>

使用工厂类创建对象

成员方法

//工厂类

public class ObjectFactory {

//成员方法

public UserDao getInstance(){

return new UserDao("张三",22);

}

静态方法

//工厂类

public class ObjectFactory {

//静态方法

public static UserDao getStaitcInstance(){

return new UserDao("李四",24);

}

单例和多例问题

scope

single: 单例

prototype：多例

是否延迟创建对象

lazy-init 是否需要延迟创建对象，默认fales,改成true就是延迟创建

default-lazy-init="true"：设置全局的延迟创建bean

注意：lazy-init只对单例（singleton）起作用

依赖注入

1：构造方法注入

<constructor-arg index="0" value="狗娃"></constructor-arg>

</bean>

构建有参构造

public User(String name){

System.out.println("name="+name);

}

2：使用set方法注入数据(推荐)

类里面提供set方法

</bean>

注入不同的数据类型：

*String类型：<value>

*int类型： <value>

*double类型： <value>

数组类型：

<array>

</array>

List类型：

<list>

</list>

Map类型：

<map>

</map>

*Properties类型：

<props>

<prop key="pro1">value1</prop>

<prop key="pro2">value2</prop>

<prop key="pro3">value3</prop>

</props>

*引用类型：

SpringIOC注解(重点)

1：导入spring的aop的jar包

spring-aop-4.2.0.RELEASE.jar

2：在applicationContext.xml引入context名称空间

<?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"

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

3：使用context的标签去扫描注解目录

<context:component-scan base-package="gz.itcast.d_annotation"></context:component-scan>

4：注解用法

//@Component("user")等价于 <bean id="user" class="gz..xxxx.User"/>

@Controller("user")

public class User {

@Resource(name="addr") //name输入对象@Component的值

private Address addr;

// 类似于<property name="addr" ref="addr"/>，不同于property注入的是，@Resource使用的是暴力反射直接注入属性

<context:annotation-config/>

@Resource // byType

@Resource(name="jobDao") // byName

private JobDao jobDao;

常用的注解：

@Component("xxx") 在springIOC工厂中创建一个对象(底下3个效果等同,为了区分)

@Resource("xxx") 在当前对象中注入springIOC工厂中的一个对象

@Repository 作用同@Component；在持久层使用

@Service 作用同@Component；在业务逻辑层使用

@Controller 作用同@Component；在控制层使用

SpringAop

springAOP概念

AOP，Aspect Object Programing 面向切面编程，主要是用于分离核心业务代码和服务代码（重复代码）

三种代理方式

1：静态代理 （关键：手写代理类，要求：必须实现接口）

写一个方法类接口

public interface IUserDao {

public void save();

public void update();

}

public class UserDaoProxy implements IUserDao{

private IUserDao userDao;

//绑定目标对象

public void bind(IUserDao userDao){

this.userDao = userDao;

}

@Override

public void save() {

System.out.println("开启事务"); //代理类实现接口后可以修改属性

//执行核心业务：

userDao.save();

System.out.println("提交事务");

}

@Override

public void update() {

System.out.println("开启事务");

//执行核心业务：

userDao.update();

System.out.println("提交事务");

}

2：jdk动态代理

//可以生成任意对象的代理类对象的工具

public class ProxyFactory {

private Object target;

//绑定被代理对象

public void bind(Object target){

this.target = target;

}

//生成一个被代理对象的代理类对象

public Object getProxyInstance(){

return Proxy.newProxyInstance(

ProxyFactory.class.getClassLoader(), // 指定类加载器，随意指定

target.getClass().getInterfaces(), // 指定代理类实现的接口（通常和被代理对象相同的接口）

new InvocationHandler() { //new一个内部类，指定代理后的处理程序

@Override //生成的代理对象 //当前方法的参数

public Object invoke(Object proxy, Method method, Object[] args) // invoke()执行处理程序

throws Throwable {

System.out.println("当前执行的方法："+method.getName());

//目标：在每个业务方式执行事务代理

System.out.println("开启事务");

//执行核心业务方法

Object result = method.invoke(target, args);

System.out.println("提交事务");

return result;

}

); // 指定代理后的处理程序（代理后要怎么做？？？）;

}

3: CGLIB子类代理方式

关键：不需要实现接口，直接生成目标对象的子类代理

步骤：

导入cglib的jar包

spring-core包

spring-aop包

编写生成子类对象的程序

//生成子类代理对象的工厂类

public class ProxyFactoryCGLIB implements MethodInterceptor{

private Object target;

//绑定目标对象

public void bind(Object target){

this.target = target;

}

//生成目标的子类代理对象

public Object getProxyInstance(){

//1.创建工具类

Enhancer en = new Enhancer();

//2.指定父类

en.setSuperclass(target.getClass());

//3.指定回调函数(底层实现需要类加载器)

en.setCallback(this);

//4.创建子类代理对象

return en.create();

}

/**

* proxy: 子类代理对象

* method: 当前调用的方法

* value: 当前调用的方法的参数

* mp: 当前方法的代理对象

@Override

public Object intercept(Object proxy, Method method, Object[] value,

MethodProxy mp) throws Throwable {

System.out.println("开启事务");

//调用核心业务：

Object result = method.invoke(target, value);

System.out.println("提交事务");

return result;

}

SpringAOP实现

SpringAOP底层使用CGLIB子类代理方式实现

SpringAOP关键词：

连接点(jointPoint)：需要关注的核心业务方法( save() update() )

切入点(pointcut)：需要切入服务代码的业务方法 ( save())

注意：

1）切入点一定是连接点

2）连接点不一定是切入点

通知(advice)：

需要在切入点上面执行的代码逻辑

*切面(aspect/advisor)：

切入点+通知 : 在某些方法(切入点)执行通知代码

导入jar包

spring-core

spring-aop

1：编写目标对象（专注核心业务）

public class UserDao {

public void save(){

System.out.println("保存数据");

}

public void update(){

System.out.println("更新数据");

}

2：编写切面类，里面写不同类型的通知

public class MyAspect {

//定义通知

/**

* 前置通知（在业务方法前面切入）

* 后置通知（在业务方法后面切入）

* 环绕通知（在业务方法前后切入））

public void before(){

System.out.println("执行前置通知");

}

3：配置切面

<aop:config>

<aop:aspect ref="myAspect(切面类id)">

<aop:pointcut id="myptID（自定义ID）" expression="execution(*(通配方法修饰符，方法返回值) gz.itcast.dao.UserDao.*(通配任意方法名)(..)(两个点省略全部参数))" />

<aop:before method="before(插入的方法)" pointcut-ref="myptID(写入切面ID)"/>

</aop:aspect>

</aop:config>

Spring整合hibernate事务

</bean>

<!--

id: 事务通知的标记

transaction-manager: 事务管理器

-->

<tx:advice id="txID" transaction-manager="hbmTxID">

<tx:attributes>

<!-- propagation: 事务传播属性

REQUIRED：如果上一个方法有事务，则加入上个方法的事务，如果没有，则新建一个事务。通常更新方法设置为这个属性

SUPPORTS：如果上个方法有事务，则加入事务，如果没有，则不加入事务。通常查询方法设置这个属性

-->

<tx:method name="set*" read-only="true"/> : 代表没开启事务，只能做查询.

<tx:method name="set*" read-only="false"/> : 代表开启了事务，CURD都可以做.

<tx:method name="save" propagation=" SUPPORTS "/>//可以指定方法

<tx:method name="*" propagation=" REQUIRED "/>//通配全部方法

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut id="myptID" expression="execution(* gz.itcast.dao.UserDao.save(..))" />

<aop:advisor advice-ref="txID" pointcut-ref="myptID"/>

</aop:config>

注意事项：

1：如果使用了spring的事务管理，则在Dao中自行获取Session时，必须使用getCurrentSession()方法

2：也可以是spring提供的HibernateTemplate工具类模板

在Dao中写用private HibernateTemplate ht;替换private SessionFactory sf;

</bean>

常见方法：

ht.save()

ht.update()

ht.get()

ht.find("hql",Object... value); 相当于createQuery(“hql”).setParameter(0,value)

ht.execute(); 使用回session对象

（重点）步骤：

1.事务管理器： HibernateTarnsactinManager

2.通知： tx:advice

3.切入点： point-cut

4.切面： <advisor advice-ref="通知" pointcur-ref="切入点"/>

String整合Struts2

在web.xml启动struts2和spring容器

<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>

//相当于监视器

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

关键： 创建struts2中使用到的Action对象

<?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"

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

<!-- 创建struts2的Action对象

scope="prototype": action必须是多例的

-->

</bean>

</beans>

在struts.xml文件引用spring容器的对象

</action>

</package>

Spring记录日志

第一种

1：写一个类与数据库对应值一致：

2：写一个util工具类，记录进入用户的操作。

//系统日志工具类

public class LogUtil {

//注入日志业务类

private ISystemlogService systemlogService;

public void setSystemlogService(ISystemlogService systemlogService) {

this.systemlogService = systemlogService;

}

//写日志

public void writeLog(JoinPoint jp){ //JoinPoint:连接点

Object target = jp.getTarget();//目标对象

String calledClassName = target.getClass().getName();//目标类的类名

String calledMethodName = jp.getSignature().getName();//调用的方法名

String func = calledClassName+":"+calledMethodName;//操作名称

if(target instanceof ISystemlogService){//遇到日志业务，则退出

return;

}

Systemlog log = new Systemlog(); //创建记录对象

//操作者：当前登录的用户

Employee operator = (Employee)ActionContext.getContext().getSession().get("loginInfo");

log.setOperator(operator);

log.setOptTime(new Date());

log.setFunc(func);

//获取ip

String ip = ServletActionContext.getRequest().getRemoteHost();

log.setIp(ip);

systemlogService.save(log); //调用service保存方法

}

3：spring的aop配置

<!— 需要插入的类配置 -->

</bean>

<aop:config>

<aop:aspect ref="logUtil">

<aop:pointcut id="logpt" expression="execution(* gz.itcast.crm.service.impl.*.*(..))" />

<aop:after method="writeLog" pointcut-ref="logpt"/>

</aop:aspect>

</aop:config>

第二种

aop日志切面.

-- 记录业务层方法执行的速度(效率).

-- 记录业务层方法的异常信息.

commons-logging-xxx.jar: 只是在控制台输出日志信息.

private Log logger = LogFactory.getLog(LogAdvice.class);

提供日志文件来记录日志.

log4j框架：

logging for java : apache组织.

log4j-1.2.17.jar

/** 定义日志记录器对象 */

private Logger logger = Logger.getLogger(LogAdvice.class);

logger.info(message);

logger.debug(message);

logger.error(message);

log4j.properties: 属性文件：//设置存储路径

第一个部分：

log4j.rootLogger = info,a,b

log4j.rootLogger = [日志级别],输出端1,输出端2

第二个部分：

log4j.logger.com.opensymphony.xwork2=error

log4j.logger.包名=日志级别

第三个部分(输出端)：

org.apache.log4j.ConsoleAppender：将日志信息输出到控制台.

org.apache.log4j.DailyRollingFileAppender：

将日志信息输出到一个日志文件，并且每天输出到一个新的日志文件.

6. slf4j框架：

simple logging fade for java : java的日志门面(日志规范).

<aop:config>

<aop:pointcut expression="execution(* cn.itcast.oa.*.*.service.impl.*.*(..))" id="pointcut"/>

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

<aop:aspect ref="logAdvice">

切入方法

<aop:around method="around" pointcut-ref="pointcut"/>

配置异常后切入

<aop:after-throwing method="error" pointcut-ref="pointcut" throwing="e"/>

</aop:aspect>

</aop:config>