Spring AOP学习笔记

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其他模块的支持

目标：

1）代理模式

静态代理

动态代理

Cglib代理

2）手动实现AOP编程【代理模式】

3）AOP编程

* 注解方式实现

* XMl配置方式实现

4） Spring DAO

Spring对jdbc操作的支持

1. 代理模式

1.1 概述

代理（Proxy）是一种设计模式，提供了对目标对象另外的访问方式；即通过代理访问目标对象。这样好处：可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。

举例：明星（邓紫棋）ß---经纪人<-------用户

目标（代理）

代理模式的关键点：代理对象与目标对象。

1.2 静态代理

静态代理，

1）代理对象，要实现与目标对象一样的接口；

2）举例:

保存用户(模拟)

Dao , 直接保存

DaoProxy, 给保存方法添加事务处理

总结静态代理：

1）可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。

2）缺点：

--》因为代理对象，需要与目标对象实现一样的接口。所以会有很多代理类，类太多。

--》一旦接口增加方法，目标对象与代理对象都要维护。

解决：

代理工厂？可以使用动态代理。

1.3 动态代理

动态代理，

1）代理对象，不需要实现接口；

2）代理对象的生成，是利用JDKAPI，动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型；);

3) 动态代理， JDK代理，接口代理；

JDK中生成代理对象的API：

|-- Proxy

static Object newProxyInstance(

ClassLoader loader, 指定当前目标对象使用类加载器

Class<?>[] interfaces, 目标对象实现的接口的类型

InvocationHandler h 事件处理器

)

动态代理总结：

代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！

(class $Proxy0 implements IuserDao)

思考：

有一个目标对象，想要功能扩展，但目标对象没有实现接口，怎样功能扩展？

Class UserDao{}

// 子类的方式

Class subclass extends UserDao{}

以子类的方式实现(cglib代理)

1.4 Cglib代理

Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。

l JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。

l CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。

l CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

Cglib子类代理：

1) 需要引入cglib – jar文件，但是spring的核心包中已经包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。

2）引入功能包后，就可以在内存中动态构建子类

3）代理的类不能为final，否则报错。

4）目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法。

在Spring的AOP编程中，

如果加入容器的目标对象有实现接口，用JDK代理；

如果目标对象没有实现接口，用Cglib代理；

2. 手动实现AOP编程

AOP 面向切面的编程，

AOP可以实现“业务代码”与“关注点代码”分离

// 保存一个用户

public void add(User user) {

Session session = null;

Transaction trans = null;

try {

session = HibernateSessionFactoryUtils.getSession(); // 【关注点代码】

trans = session.beginTransaction(); // 【关注点代码】

session.save(user); // 核心业务代码

trans.commit(); //…【关注点代码】

} catch (Exception e) {

e.printStackTrace();

if(trans != null){

trans.rollback(); //..【关注点代码】

}

} finally{

HibernateSessionFactoryUtils.closeSession(session); ////..【关注点代码】

}

分析总结：

关注点代码，就是指重复执行的代码。

业务代码与关注点代码分离，好处？

--à 关注点代码写一次即可；

-à开发者只需要关注核心业务；

-à运行时期，执行核心业务代码时候动态植入关注点代码；【代理】

如何分离？

过程式/对象式/代理模式分离

3. AOP编程

3.1 概述：

Aop， aspect object programming 面向切面编程

功能：让关注点代码与业务代码分离！

关注点,

重复代码就叫做关注点；

切面，

关注点形成的类，就叫切面类！切面类一般用于，日志、安全、权限方面使用。

面向切面编程，就是指对很多功能都有的重复的代码抽取，再在运行的时候网业务方法上动态植入“切面类代码”。切面中的方法叫通知。

切入点，(相当于条件)

执行目标对象方法，动态植入切面代码。

可以通过切入点表达式，指定拦截哪些类的哪些方法；给指定的类在运行的时候植入切面类代码。

3.2 注解方式实现AOP编程

步骤：

1）先引入aop相关jar文件（aspectj aop优秀组件）

spring-aop-3.2.5.RELEASE.jar 【spring3.2源码】

aopalliance.jar 【spring2.5源码/lib/aopalliance】

aspectjweaver.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】

aspectjrt.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】

注意：用到spring2.5版本的jar文件，如果用jdk1.7可能会有问题。

需要升级aspectj组件，即使用aspectj-1.8.2版本中提供jar文件提供。

2） bean.xml中引入aop名称空间

3）开启aop注解

4) 使用注解

@Aspect 指定一个类为切面类

@Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))") 指定切入点表达式（相当于条件）

@Before("pointCut_()") 前置通知: 目标方法之前执行

@After("pointCut_()") 后置通知：目标方法之后执行（始终执行）

@AfterReturning("pointCut_()") 返回后通知：执行方法结束前执行(异常不执行)

@AfterThrowing("pointCut_()") 异常通知: 出现异常时候执行

@Around("pointCut_()") 环绕通知：环绕目标方法执行

1. IUserDao.java

// 接口

public interface IUserDao {

void save();

}

2. UserDao.java

/**

* 目标对象

* @author Jie.Yuan

@Component // 加入容器

public class UserDao implements IUserDao{

@Override

public void save() {

System.out.println("-----核心业务：保存！！！------");

}

3. Aop.java 切面类

@Component

@Aspect // 指定当前类为切面类

public class Aop {

// 指定切入点表单式：拦截哪些方法；即为哪些类生成代理对象

@Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")

public void pointCut_(){

}

// 前置通知 : 在执行目标方法之前执行

@Before("pointCut_()")

public void begin(){

System.out.println("开始事务/异常");

}

// 后置/最终通知：在执行目标方法之后执行【无论是否出现异常最终都会执行】

@After("pointCut_()")

public void after(){

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

}

// 返回后通知：在调用目标方法结束后执行【出现异常不执行】

@AfterReturning("pointCut_()")

public void afterReturning() {

System.out.println("afterReturning()");

}

// 异常通知：当目标方法执行异常时候执行此关注点代码

@AfterThrowing("pointCut_()")

public void afterThrowing(){

System.out.println("afterThrowing()");

}

// 环绕通知：环绕目标方式执行

@Around("pointCut_()")

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:p="http://www.springframework.org/schema/p"

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

<context:component-scan base-package="cn.itcast.e_aop_anno"></context:component-scan>

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

App.java

public class App {

ApplicationContext ac =

new ClassPathXmlApplicationContext("cn/itcast/e_aop_anno/bean.xml");

// 目标对象有实现接口，spring会自动选择“JDK代理”

@Test

public void testApp() {

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

System.out.println(userDao.getClass());

userDao.save();

}

// 目标对象没有实现接口， spring会用“cglib代理”

@Test

public void testCglib() {

OrderDao orderDao = (OrderDao) ac.getBean("orderDao");

System.out.println(orderDao.getClass());

orderDao.save();

}

3.3 XML方式实现AOP编程

Xml实现aop编程：

1）引入jar文件【aop 相关jar， 4个】

2）引入aop名称空间

3）aop 配置

* 配置切面类（重复执行代码形成的类）

* aop配置

拦截哪些方法 / 拦截到方法后应用通知代码

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

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

<aop:config>

<aop:pointcut expression="execution(* cn.itcast.f_aop_xml.*.*(..))" id="pt"/>

<aop:aspect ref="aop">

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

<aop:before method="begin" pointcut-ref="pt"/>

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

<aop:after-returning method="afterReturning" pointcut-ref="pt"/>

<aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>

</aop:aspect>

</aop:config>

</beans>

3.4 切入点表达式

切入点表达式,

可以对指定的“方法”进行拦截；从而给指定的方法所在的类生层代理对象。

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

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

<aop:config>

<aop:pointcut expression=" not execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>

<aop:aspect ref="aop">

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

</aop:aspect>

</aop:config>

</beans>

4. Spring对jdbc支持

使用步骤：

1）引入jar文件

spring-jdbc-3.2.5.RELEASE.jar

spring-tx-3.2.5.RELEASE.jar

2）优化

< aop:aspect>和< aop:advisor>的区别

< aop:aspect>：定义AOP通知器、大多用于日志，缓存
< aop:advisor>：定义切面、大多用于事务管理。

比如，下面是一个对Service包上所有方法的切面配置

<aop:config>

<aop:pointcut id="serviceOperation"

expression="execution(* *..service*..*(..))"/>

<aop:advisor pointcut-ref="serviceOperation"

advice-ref="txAdvice"/>

</aop:config>

表达式所处位置如上pointcut的位置。

配置这个为了更好控制切面上的事务，下面是一个事物配置的简单例子：

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

<tx:attributes>

<tx:method name="delete*" rollback-for="Exception"/>

<tx:method name="save*" rollback-for="Exception"/>

<tx:method name="update*" rollback-for="Exception"/>

<tx:method name="*" read-only="true" rollback-for="Exception"/>

</tx:attributes>

</tx:advice>

通过切面、通知的配置，就为所有的delete/save/update开头的方法添加上了一致性事务，对其他方法添加上了只读事务。

表示service包下的所有方法为为事务管理。

spring与hibernate整合

1、注入SessionFactory方式

1、在配置文件中，引入sessionFactory。

<!--

引入sessionFactory 方法一

-->

<value>classpath:hibernate.cfg.xml</value>

</property>

</bean>

<!--

引入sessionFactory 方法二

-->

<!--

映射文件所在的路径

-->

<list>

<!--

spring容器会去该包及子包下搜索所有的映射文件

-->

<value>com/itheima12/spring/hibernate/transaction/domain</value>

</list>

</property>

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>

<prop key="hibernate.hbm2ddl.auto">update</prop>

</props>

</property>

</bean>

2、继承HibernateDaoSupport

public class PersonDaoImpl extends HibernateDaoSupport implements PersonDao{

public void savePerson(Person person) {

// TODO Auto-generated method stub

this.getHibernateTemplate().save(person);

}

2、注入HibernateTemplate方式

配置文件如下所示：

</bean>

DAO编码如下所示：

private HibernateTemplate hibernateTemplate;

// 定义一个Logger，便于它及其子类计入日志用

protected Logger logger = Logger.getLogger(this.getClass());

public HibernateTemplate getHibernateTemplate() {

return hibernateTemplate;

}

public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {

this.hibernateTemplate = hibernateTemplate;

}

@Override

public <T> void saveEntity(T entity) {

// TODO Auto-generated method stub

this.hibernateTemplate.saveOrUpdate(entity);

}

3、注入jdbcTemplate方式

这种配置是使用Spring对JDBC的封装，而非Hibernate。即不加载Hibernate容器，直接使用Spring对JDBC的封装来操作数据库

第一种配置：给DAO类注入数据源dataSource

配置如下:

Xml代码

<bean id="userManageImpl" class="com.nos.business.springJDBC.impl.UserManageImpl">
<property name="dataSource" ref="dataSource" />
</bean>

DAO编码如下所示：

Java代码

public class UserManageImpl implements IUserManage{
private JdbcTemplate jdbcTemplate;
@Resource(name="dataSource")
public void setDataSource(DataSource dataSource){
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
@Override
public void add(UserVo vo)
{
jdbcTemplate.update("insert into user_info(name,sex) values(?,?)", new Object[]{vo.getName(), vo.getSex()});
}
}

第二种配置：直接给Dao类注入JdbcTemplate

　　配置如下：

Xml代码

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource" />
</bean>

DAO编码如下所示：

Java代码

public class UserManageImpl2 implements IUserManage{
@Resource
private JdbcTemplate jdbcTemplate;
@Override
public void add(UserVo vo)
{
jdbcTemplate.update("insert into user_info(name,sex) values(?,?)", new Object[]{vo.getName(), vo.getSex()});
}
}

spring的声明式事务处理：

(让程序员不再关注事务)

声明：由程序告诉spring容器，什么样的目标方法采用什么样的事务策略

事务处理：是由spring容器来完成的

crud操作：程序员做的事情

1、XML方式实现声明式事务处理

以下是声明式事务处理的例子：

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

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

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-2.5.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

http://www.springframework.org/schema/tx

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

<!--

引入properties配置文件

-->

<bean

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<value>classpath:jdbc.properties</value>

</property>

</bean>

<bean id="dataSource" destroy-method="close"

class="org.apache.commons.dbcp.BasicDataSource">

</bean>

<!--

引入sessionFactory

-->

<value>classpath:hibernate.cfg.xml</value>

</property>

</bean>

<!--

映射文件所在的路径

-->

<list>

<!--

spring容器会去该包及子包下搜索所有的映射文件

-->

<value>com/itheima12/spring/hibernate/transaction/domain</value>

</list>

</property>

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>

<prop key="hibernate.hbm2ddl.auto">update</prop>

</props>

</property>

</bean>

</property>

</bean>

</property>

</bean>

<!--

事务管理器

-->

</property>

</bean>

<!--

事务的声明

-->

<tx:advice transaction-manager="transactionManager" id="tx">

<tx:attributes>

<!--

name: 目标方法的范围

isolation 隔离机制

propagation 传播属性解决事务的嵌套问题

read-only

true 只读事务

false 读写事务

-->

<tx:method name="save*" isolation="DEFAULT" propagation="REQUIRED"

read-only="false"/>

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut

expression="execution(* com.itheima12.spring.hibernate.transaction.service.impl.*.*(..))"

id="perform"/>

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

</aop:config>

</beans>

2、注解方式实现方式实现声明式事务处理

使用注解实现Spring的声明式事务管理，更加简单！

步骤：

1）必须引入Aop相关的jar文件

2） bean.xml中指定注解方式实现声明式事务管理以及应用的事务管理器类

3）在需要添加事务控制的地方，写上: @Transactional

@Transactional注解：

1）应用事务的注解

2）定义到方法上：当前方法应用spring的声明式事务

3）定义到类上：当前类的所有的方法都应用Spring声明式事务管理;

4）定义到父类上：当执行父类的方法时候应用事务。

Bean.xm

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

</bean>

</bean>

</bean>

<context:component-scan base-package="cn.itcast.b_anno"></context:component-scan>

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

</beans>

DeptService

@Service

public class DeptService {

@Resource

private DeptDao deptDao;

* 事务控制？

@Transactional

public void save(Dept dept){

deptDao.save(dept);

int i = 1/0;

deptDao.save(dept);

}

事务属性

@Transactional(

readOnly = false, // 读写事务

timeout = -1, // 事务的超时时间不限制

noRollbackFor = ArithmeticException.class, // 遇到数学异常不回滚

isolation = Isolation.DEFAULT, // 事务的隔离级别，数据库的默认

propagation = Propagation.REQUIRED // 事务的传播行为

)

public void save(Dept dept){

deptDao.save(dept);

int i = 1/0;

deptDao.save(dept);

}

Spring HibernateTransactionManager事物管理类

我们在Spring里通常把事务交给HibernateTransactionManager来处理，通过Aop配置事务，把事务交给该类之后就会由该类来帮我们管理和提供事务。

<context:annotation- config/>的作用：

使用<context:annotation- config/>隐式地向 Spring容器注册AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor以及PersistenceAnnotationBeanPostProcessor这4个BeanPostProcessor。

因为：　使用@Autowired注解，必须事先在Spring容器中声明AutowiredAnnotationBeanPostProcessor的Bean：

Spring AOP学习笔记的更多相关文章

Spring AOP学习笔记01：AOP概述
1. AOP概述软件开发一直在寻求更加高效.更易维护甚至更易扩展的方式.为了提高开发效率,我们对开发使用的语言进行抽象,走过了从汇编时代到现在各种高级语言繁盛之时期:为了便于维护和扩展,我们对某些相 ...
Spring AOP学习笔记02：如何开启AOP
上文简要总结了一些AOP的基本概念,并在此基础上叙述了Spring AOP的基本原理,并且辅以一个简单例子帮助理解.从本文开始,我们要开始深入到源码层面来一探Spring AOP魔法的原理了. 要使用 ...
Spring AOP学习笔记03：AOP的核心实现之获取增强器
上文讲了spring是如何开启AOP的,简单点说就是将AnnotationAwareAspectJAutoProxyCreator这个类注册到容器中,因为这个类最终实现了BeanPostProcess ...
Spring AOP学习笔记05：AOP失效的罪因
前面的文章中我们介绍了Spring AOP的简单使用,并从源码的角度学习了其底层的实现原理,有了这些基础之后,本文来讨论一下Spring AOP失效的问题,这个问题可能我们在平时工作中或多或少也会碰到 ...
Spring AOP学习笔记(1)-概念
1.Aspect 横切在多个类的一个关注点,在Spring AOP中,aspect实现是一个规则的类或@Aspect标注的规则类.例如:事务管理 2.Join point 程序执行过程中的一个点,例如 ...
Spring AOP学习笔记04：AOP核心实现之创建代理
上文中,我们分析了对所有增强器的获取以及获取匹配的增强器,在本文中我们就来分析一下Spring AOP中另一部分核心逻辑--代理的创建.这部分逻辑的入口是在wrapIfNecessary()方法中紧接 ...
Spring入门IOC和AOP学习笔记
Spring入门IOC和AOP学习笔记概述 Spring框架的核心有两个: Spring容器作为超级大工厂,负责管理.创建所有的Java对象,这些Java对象被称为Bean. Spring容器管理容 ...
【转】Spring.NET学习笔记——目录
目录前言 Spring.NET学习笔记——前言第一阶段:控制反转与依赖注入IoC&DI Spring.NET学习笔记1——控制反转(基础篇) Level 200 Spring.NET学习笔 ...
Spring MVC 学习笔记12 —— SpringMVC+Hibernate开发（1）依赖包搭建
Spring MVC 学习笔记12 -- SpringMVC+Hibernate开发(1)依赖包搭建用Hibernate帮助建立SpringMVC与数据库之间的联系,通过配置DAO层,Service ...

随机推荐

HTTP 416
真是活久见, 竟然遇到了HTTP 416 参照 http://baike.baidu.com/view/1790469.htm , Requested Range Not Satisfiable 如果 ...
png格式的图片在IE6 下透明解决方案
FF和IE7已经直接支持透明的png图了,下面这个主要是解决IE6下透明PNG图片有灰底的 style="FILTER: progid:DXImageTransform.Microsoft. ...
MVC基于角色权限控制--权限过滤
用户访问服务器实际上就是访问控制器下的方法,因此在权限控制就是控制器方法的访问权限为了方便控制,我们可以建立一个基类控制器(BaseController),让需要的控制器继承这个控制器即可,在Bas ...
iOS 证书， provision profile作用
证书(certificate): 给app签名用的,针对开发者,app可以装在真机上的前提条件之一是被签名 Provision profile: 在app包中,用来校验app是否可以被装在真机上,一个 ...
JAVA_Class.forName
Class.forName(xxx.xx.xx) 返回的是一个类 ,作用是要求JVM查找并加载指定的类,也就是说JVM会执行该类的静态代码段 --------- 首先,在java里面任何class都要 ...
UNITY Profiler 真机调试
1,WIFI方式, 2,ADB方式WIFI方式:数据通过WIFI在手机和电脑间传输,且手机和电脑必须在一个网段ADB方式如下:数据通过数据线在手机和电脑间传输.显然ADB方式速度快,无网段限制,比较好 ...
[C语言]在命令行编译执行程序
----------------------------------------------------------------------------------------- [开始] 1. 在M ...
httpClient服务端编写
以前用过HttpClient,给你说几个关键的地方吧: 1. 首先,发送的时候 HttpClient client = new HttpClient(); PostMethod method = ne ...
为了显示此页面，Firefox 必须发送将重复此前动作的数据（例如搜索或者下订单）
火狐浏览器重新加载页面出现下面提示,必须要点击“重新发送”才能完成刚才的请求: 这个是火狐的一个提示功能主要是防止同一页面的数据反复提交: 解决方法: 不要用location.reload();来刷新 ...
Redis Cluster在线迁移
由于之前的redis cluster物理硬件性能不足.决定升级到更好的服务器上.考虑到redis是核心生产数据库,决定在线迁移,迁移过程,不中断服务. 下面是测试环境的完成迁移步骤:1. 原环境(测试 ...

Spring AOP学习笔记

Spring AOP学习笔记的更多相关文章

随机推荐

热门专题