- 浏览: 251109 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (221)
- A序 (4)
- 系统学习(读书笔记) (5)
- Computer-base (14)
- RFC-协议规范 (9)
- OS-windows (3)
- OS-linux (10)
- 项目管理-需求设计 (2)
- 设计模式 (1)
- Java-基础-抽象规范 (15)
- Java-基础-core-code (15)
- Java-Thread (15)
- JAVA-stream 流 (1)
- JAVA-socket (13)
- JAVA-SSL (5)
- JAVA-RMI-JMX-OSGI (7)
- java-web (6)
- 工具 (19)
- W3C (16)
- DB (12)
- 读书笔记 (5)
- 中间件 (1)
- C/C++ (1)
- JAVA-JAXB (3)
- Java-UI (1)
- JAVA命令 (1)
- JVM实战 (1)
- java-base (3)
- maven (1)
最新评论
-
Nabulio:
厉害
tomcat 源码学习 -
zbz:
例子很简单,可是怎么设置访问账号和密码呢?注释掉的那段不起作用 ...
jmx 实例--最简单的例子 -
zk302:
格式可以优化下
sql-经典例子练习 -
tuspark:
eclipse的访问控制图标,可以看这篇《eclipse的访问 ...
Eclipse(四)常用设置 -
xlshl43:
流比呀。。。但这排版看的有点蛋疼。。。
Java核心代码(二)Class loader
/------------------------------------------------------------------------------------\
| A类-精华 |
\------------------------------------------------------------------------------------/
1、IOC
1, 自动扫描bean
IOC用法--只会注入属性,不会把bean纳入spring的管理范围
xml配置上百个bean节点时,很难维护。
spring2.5引入了bean自动扫描机制(自动把bean纳入spring的管理范围)
@Component(泛指),@Service,@Controller(action),@Repository(dao组件,与数据库相关的)注解的类,
<context:component-scan base-package="cn.itest"/>//需要自动扫描的包//引入context命名空间
@Service("personService")
public class PersonServiceBean implements PersonService {
@Resource //Field//用注解--------------------------------------------------------------------//
//等效于@Resource(name="pesronDao")
private PersonDao personDao;
<context:component-scan base-package="cn.itcast"/>
//它已包含 <context:annotation-config/> ,所以不需要在导入<context:annotation-config了
<context:annotation-config/>
//annotation-config隐式注册了CommonAnnotationBeanPostProcessor等
3, spring声明式事务
1、tx标签拦截器-------------------方法级别的-------------------
//<aop:pointcut/><tx:advice/><aop:advisor/>元素都可以是多个,就可以实现方法级别了
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="*" propagation="REQUIRED" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="interceptorPointCuts" expression="execution(* com.bluesky.spring.dao.*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="interceptorPointCuts" />
</aop:config>
2、全注解-------------------方法级别的-------------------spring官方推荐
<context:annotation-config />
<context:component-scan base-package="com.bluesky"/>//它已包含 <context:annotation-config/>
<tx:annotation-driven transaction-manager="transactionManager"/>
java代码中
@Transactional
@Component("userDao")
public class UserDaoImpl extends HibernateDaoSupport{
@Transactional(isolation = Isolation.READ_COMMITTED)
public void test1(){...}
}
@Transactional 的所有可选属性如下:
propagation
isolation
readOnly:使用Hibernate时,它告知Hibernate不要在只读事务中检测和刷新变化
rollbackFor或“-”
noRollbackFor或“+”
Spring默认:(RuntimeException)回滚,checked异常提交。
DB并发问题:
查询MysqL默认隔离级别语句:select @@tx_isolation;
修改MysqL默认隔离级别语句:
set transaction isolation level read uncommitted;
修改后,给delete设置断点,就可以看到dirty read了
public void delete(){
jdbcTemplate.update("delete from person where id=8");
jdbcTemplate.update("delete from persons where id=9");
}
可见,SQL提交后,就已经
恢复默认级别:
set transaction isolation level Repeatable Read
隔离级别:
Read Uncommited:不提交读
Read Commited(Oracle默认):提交读-不可以“重复读”
Repeatable Read(MysqL默认)
可(以)“重复读”:一个事务内,多次(有时,有这种需要)读同一数据时,结果应该一致。
Serialiazble:序列化读
问题:
1. 脏读 :事务2读到了事务1修改后的数据(这个数据可能被回滚,也可能被提交)
2. 不可“重复读” :一个事务内,多次(有时,有这种需要)读同一数据时,结果应该一致。
spring可以管理事务的原因:
Spring管理DB,Sevice调用多个Dao(DML操作),都会先保存在同一Session中
发生异常时,Spring把这个Session中的DML操作回滚。
AOP概念:Aspect,Joinpoint,Advice,Pointcut,introduction,TargetObject,AOPProxy,weaving等。
spring-AOP概念
AOP有三个最核心的概念:Advice、Pointcut和Advisor。
Advice是你想【向其他程序内部不同地方】注入的代码。
Pointcut定义了(需要注入Advice的)位置(通常是某个特定的类的一个public方法),
Advisor是Pointcut和Advice的装配器,是将Advice注入程序中预定义位置的代码。
3,基础
src:为类路径
类路径实例化spring容器
ApplicationContext ctx=new ClassPathXmlApplicationContext(new String[]{"beans.xml"});
spring的规范
bean命名==变量命名
List users,不要List userList
属性用封装类,局部变量用int
接口中加方法注释,实现类中不用加
注解
不是耦合,因为它只改变了一个类
很少改动的用注解,因为要编译;经常改变的用xml配置
轻量级重量级框架区别
容器使用的服务少-轻量级,多时spring就变为重量级了
spring的作用范围
1,signleton,prototype
2,web下request,session
spring默认管理bean
signleton,判断bean1==bean2
启动时实例化bean,在无参构造中System.out
生命周期,至spring容器结束
IOC
PersonService中
PersonDao pDao=new PersonDao()//pDao在service的内部被创建及维护
IOC后,只需要声明一下PersonDao
IOC用法--只会注入属性,不会把bean纳入spring的管理范围
1,set对各种类型的装配
1,单个属性value
2,各种集合set,list,map,properties[]
2,Field//用注解--------推荐
@Resource默认按名称(id)装配,找不到在按类型
@Autowired按类型进行装配//不推荐@Autowired
3,构造
4,spring2.5引入了组件自动扫描机制(其实是Field方式)
xml配置上百个bean节点时,很难维护。
从类路径下寻找标注了@Component(泛指),@Service,@Controller(action),@Repository(dao组件,与数据库相关的)注解的类,
并把这些类纳入到spring容器中管理
引入context命名空间
<context:component-scan base-package="cn.itest"/>//需要自动扫描的包
@Service("personService")
public class PersonServiceBean implements PersonService {
@Resource //Field//用注解--------------------------------------------------------------------//
//等效于@Resource(name="pesronDao")
private PersonDao personDao;
<context:component-scan base-package="cn.itcast"/>
//它已包含 <context:annotation-config/> ,所以不需要在导入<context:annotation-config了
<context:annotation-config/>
//annotation-config隐式注册了CommonAnnotationBeanPostProcessor等
//用于注入(IOC 只会注入属性,不会把bean纳入spring的管理范围),
<====================== 3,spring-AOP====================== >
1,注解方式:需要<aop:aspectj-autoproxy/>//"aop:"说明需要xmlns:aop
@Aspect
public class MyInterceptor0 {
@Pointcut("execution (* cn.itcast.service.impl.PersonServiceBean0.*(..))")
private void anyMethod(){}//声明一个pointcut
@Before("anyMethod() && args(name)")//增加pointcut参数限制
public void doAccessCheck(String name){
System.out.println("before advice:"+name);
}
@AfterReturning(pointcut="anyMethod()",returning="result")
public void doAfterReturning(String result){
System.out.println("after advice:"+result);
}
@After("anyMethod()")//最终通知finally
public void doAfter(){
System.out.println("after finally advice");
}
@AfterThrowing(pointcut="anyMethod()",throwing="e")
public void doAfterThrowing(Exception e){
System.out.println("after throw advice:"+e);
}
@Around("anyMethod()")
public Object doAround(ProceedingJoinPoint pjp)throws Throwable{
System.out.println("进入 around");
Object result=pjp.proceed();
System.out.println("退出 around");
return result;
}
}
<aop:aspectj-autoproxy/>
<bean id="myInterceptor0" class="cn.itcast.service.MyInterceptor0"/>
<bean id="personService0" class="cn.itcast.service.impl.PersonServiceBean0"/>
2,xml配置方式://不需要<aop:aspectj-autoproxy/>
<bean id="aspectBean" class="cn.itcast.service.MyInterceptor"/>
<bean id="personService" class="cn.itcast.service.impl.PersonServiceBean"/>
<aop:config>
<aop:aspect id="asp" ref="aspectBean">
<aop:pointcut id="mycut" expression="execution(* cn.itcast.service.impl.PersonServiceBean.*(java.lang.String,..))"/>
<aop:before pointcut-ref="mycut" method="doAccessCheck"/>
<aop:after-returning pointcut-ref="mycut" method="doAfterReturning"/>
<aop:after-throwing pointcut-ref="mycut" method="doAfter"/>
<aop:after pointcut-ref="mycut" method="doAfterThrowing"/>
<aop:around pointcut-ref="mycut" method="doAround"/>
</aop:aspect>
</aop:config>
MyInterceptor类,去掉所有的注解
<====================== 4,spring-Hibernate-JDBC====================== >
spring-Hibernate
UserDao extends HibernateDaoSupport,后,就不用setSessionFactory
但xml里还是要的
spring-JDBC
userDao需要
<property name="dataSource" ref="dataSource"/>
private JdbcTemplate jdbcTemplate;
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate =new JdbcTemplate(dataSource);
}
//IOC不需要属性,只需要set方法
不需要private DataSource dataSource,有setDataSource就可以了
/------------------------------------------------------------------------------------\
| B类-所有 |
\------------------------------------------------------------------------------------/
<====================== 1,声明式事务====================== >
###:方法1,2,3已过时,方法4,5主流
1,代理模式-------------------类级别的-------------------但是要写很多的代理
<!-- 每个要加事务的service对应一个 *ServiceProxyBean-->
<bean id="rightService".../>
<bean id="rightServiceProxyBean" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager"> //配置事务管理器de实现类
<ref bean="transactionManager"/>
</property>
<property name="target"> //配置要拦截的serivce
<ref bean="rightService"/>
</property>
// <property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao" />//可有可无
<property name="transactionAttributes"> //配置事务属性
<props>
<prop key="find*">PROPAGATION_REQUIRED, readOnly</prop>
<prop key="add*">PROPAGATION_REQUIRED, -AddOrModifyException</prop>
<prop key="*">PROPAGATION_REQUIRED</prop>
//还有隔离级别没设
</props>
</property>
</bean>
然后再(ssh1下)被action调用
<bean name="/role/roleadd" class="com.tarena.oss.web.actions.RoleAction">
<property name="service">
<ref bean="roleServiceProxyBean"/>
</property>
<property name="rservice">
<ref bean="rightServiceProxyBean"/>
</property>
</bean>
2,多个Bean共享一个代理基类
<bean id="transactionBase"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
lazy-init="true" abstract="true">
...把<property name="target">拿出来,其他不变
</bean>
<bean id="rightServiceProxyBean" parent="transactionBase" >
<property name="target" ref="rightService" />
</bean>
3,拦截器----------------------类级别的-------------------
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager" ref="transactionManager" /> //配置事务管理器de实现类
<property name="transactionAttributes"> // 配置事务属性
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list>
<value>*Service</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
</list>
</property>
</bean>
4, tx标签拦截器-------------------方法别的-------------------
//<aop:pointcut/><tx:advice/><aop:advisor/>元素都可以是多个,就可以实现方法级别了
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="*" propagation="REQUIRED" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="interceptorPointCuts" expression="execution(* com.bluesky.spring.dao.*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="interceptorPointCuts" />
</aop:config>
5,全注解-------------------方法别的-------------------spring官方推荐
<context:annotation-config />
<context:component-scan base-package="com.bluesky" />
<tx:annotation-driven transaction-manager="transactionManager"/>
java代码中
@Transactional
@Component("userDao")
public class UserDaoImpl extends HibernateDaoSupport{
@Transactional(isolation = Isolation.READ_COMMITTED)
public void test1(){...}
}
@Transactional 的所有可选属性如下:
propagation
isolation
readOnly:使用Hibernate时,它告知Hibernate不要在只读事务中检测和刷新变化
rollbackFor或“-”
noRollbackFor或“+”
Spring默认:(RuntimeException)回滚,checked异常提交。
DB并发问题:
查询MysqL默认隔离级别语句:select @@tx_isolation;
修改MysqL默认隔离级别语句:
set transaction isolation level read uncommitted;
修改后,给delete设置断点,就可以看到dirty read了
public void delete(){
jdbcTemplate.update("delete from person where id=8");
jdbcTemplate.update("delete from persons where id=9");
}
可见,SQL提交后,就已经
恢复默认级别:
set transaction isolation level Repeatable Read
隔离级别:
Read Uncommited:不提交读
Read Commited(Oracle默认):提交读-不可以“重复读”
Repeatable Read(MysqL默认)
可(以)“重复读”:一个事务内,多次(有时,有这种需要)读同一数据时,结果应该一致。
Serialiazble:序列化读
问题:
1. 脏读 :事务2读到了事务1修改后的数据(这个数据可能被回滚,也可能被提交)
2. 不可“重复读” :一个事务内,多次(有时,有这种需要)读同一数据时,结果应该一致。
spring可以管理事务的原因:
Spring管理DB,Sevice调用多个Dao(DML操作),都会先保存在同一Session中
发生异常时,Spring把这个Session中的DML操作回滚。
<====================== 2,spring-公共基础====================== >
1,通用的AOP术语,这并不直观。如果Spring使用它自己的术语,那么就更显得混淆。
Aspect(切面):事务管理就是一个很好的横切关系的例子。切面作为顾问(advisor)和拦截(interceptor)应用于Spring中。
aspects的2种方式:
regular classes (the schema-based approach)
regular classes annotated with the @Aspect annotation (the@AspectJ style).--spring2.0以后
Joinpoint(接合点):
Spring中,一个接合点通常是方法调用。Spring并不明显地使用"接合点"作为术语;
接合点信息可以通过MethodInvocation的参数穿过拦截器访问,相当于实现org.springframework.aop.Poinkcut接口。
Advice(通知):
action taken by an aspect at a particular join point.//被AOP框架使用的“特定接合点”
"around,""before" and "after","after exception" advice.
around adive--最常用
Many AOP frameworks, including Spring,model an advice as an interceptor, maintaining a chain of interceptors around the join point.
Pointcut(切入点):AOP框架必须允许开发者指定切入点:例如使用正则表达式。
Introduction(引入):
向一个通知类中添加方法或成员变量。Spring允许你向任何通知类中引入新接口。
有自己的Advisor:IntroductionAdvisor
Target object(标签对象):
包含接合点的对象。也被通知对象或者代理对象所引用。
object being advised by one or more aspects. Also referred to as the advised object.
Since Spring AOP is implemented using runtime proxies, this object will always be a proxied object.
AOP proxy(AOP代理):
被AOP框架创建的对象,包括通知。在Spring中,一个AOP代理将会是一个JDK dynamic proxy or a CGLIB proxy.
Weaving(编织):
聚合切面以生成一个通知对象。这可以在编译时(比如使用AspectJ编译器)或在运行时完成。
Spring,如同其它纯Java AOP框架一样,在运行时完成编织。
2,spring-AOP概念
AOP也是非常抽象难以理解的
AOP有三个最核心的概念:Advice、Pointcut和Advisor。
Advice是你想向其他程序内部不同地方注入的代码。
Pointcut定义了需要注入Advisor(应该为Advice吧)的位置(通常是某个特定的类的一个public方法),
Advisor是Pointcut和Advice的装配器,是将Advice注入程序中预定义位置的代码。
3,基础
src:为类路径
类路径实例化spring容器
ApplicationContext ctx=new ClassPathXmlApplicationContext(new String[]{"beans.xml"});
spring的规范
bean命名==变量命名
List users,不要List userList
属性用封装类,局部变量用int
接口中加方法注释,实现类中不用加
注解
不是耦合,因为它只改变了一个类
很少改动的用注解,因为要编译;经常改变的用xml配置
轻量级重量级框架区别
容器使用的服务少-轻量级,多时spring就变为重量级了
spring的作用范围
1,signleton,prototype
2,web下request,session
spring默认管理bean
signleton,判断bean1==bean2
启动时实例化bean,在无参构造中System.out
生命周期,至spring容器结束
IOC
PersonService中
PersonDao pDao=new PersonDao()//pDao在service的内部被创建及维护
IOC后,只需要声明一下PersonDao
IOC用法--只会注入属性,不会把bean纳入spring的管理范围
1,set对各种类型的装配
1,单个属性value
2,各种集合set,list,map,properties[]
2,Field//用注解--------推荐
@Resource默认按名称(id)装配,找不到在按类型
@Autowired按类型进行装配//不推荐@Autowired
3,构造
4,spring2.5引入了组件自动扫描机制(其实是Field方式)
xml配置上百个bean节点时,很难维护。
从类路径下寻找标注了@Component(泛指),@Service,@Controller(action),@Repository(dao组件,与数据库相关的)注解的类,
并把这些类纳入到spring容器中管理
引入context命名空间
<context:component-scan base-package="cn.itest"/>//需要自动扫描的包
@Service("personService")
public class PersonServiceBean implements PersonService {
@Resource //Field//用注解--------------------------------------------------------------------//
//等效于@Resource(name="pesronDao")
private PersonDao personDao;
<context:component-scan base-package="cn.itcast"/>
//它已包含 <context:annotation-config/> ,所以不需要在导入<context:annotation-config了
<context:annotation-config/>
//annotation-config隐式注册了CommonAnnotationBeanPostProcessor等
//用于注入(IOC 只会注入属性,不会把bean纳入spring的管理范围),
<====================== 3,spring-AOP====================== >
1,注解方式:需要<aop:aspectj-autoproxy/>//"aop:"说明需要xmlns:aop
@Aspect
public class MyInterceptor0 {
@Pointcut("execution (* cn.itcast.service.impl.PersonServiceBean0.*(..))")
private void anyMethod(){}//声明一个pointcut
@Before("anyMethod() && args(name)")//增加pointcut参数限制
public void doAccessCheck(String name){
System.out.println("before advice:"+name);
}
@AfterReturning(pointcut="anyMethod()",returning="result")
public void doAfterReturning(String result){
System.out.println("after advice:"+result);
}
@After("anyMethod()")//最终通知finally
public void doAfter(){
System.out.println("after finally advice");
}
@AfterThrowing(pointcut="anyMethod()",throwing="e")
public void doAfterThrowing(Exception e){
System.out.println("after throw advice:"+e);
}
@Around("anyMethod()")
public Object doAround(ProceedingJoinPoint pjp)throws Throwable{
System.out.println("进入 around");
Object result=pjp.proceed();
System.out.println("退出 around");
return result;
}
}
<aop:aspectj-autoproxy/>
<bean id="myInterceptor0" class="cn.itcast.service.MyInterceptor0"/>
<bean id="personService0" class="cn.itcast.service.impl.PersonServiceBean0"/>
2,xml配置方式://不需要<aop:aspectj-autoproxy/>
<bean id="aspectBean" class="cn.itcast.service.MyInterceptor"/>
<bean id="personService" class="cn.itcast.service.impl.PersonServiceBean"/>
<aop:config>
<aop:aspect id="asp" ref="aspectBean">
<aop:pointcut id="mycut" expression="execution(* cn.itcast.service.impl.PersonServiceBean.*(java.lang.String,..))"/>
<aop:before pointcut-ref="mycut" method="doAccessCheck"/>
<aop:after-returning pointcut-ref="mycut" method="doAfterReturning"/>
<aop:after-throwing pointcut-ref="mycut" method="doAfter"/>
<aop:after pointcut-ref="mycut" method="doAfterThrowing"/>
<aop:around pointcut-ref="mycut" method="doAround"/>
</aop:aspect>
</aop:config>
MyInterceptor类,去掉所有的注解
<====================== 4,spring-Hibernate-JDBC====================== >
spring-Hibernate
UserDao extends HibernateDaoSupport,后,就不用setSessionFactory
但xml里还是要的
spring-JDBC
userDao需要
<property name="dataSource" ref="dataSource"/>
private JdbcTemplate jdbcTemplate;
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate =new JdbcTemplate(dataSource);
}
//IOC不需要属性,只需要set方法
不需要private DataSource dataSource,有setDataSource就可以了
发表评论
-
jetty tomcat
2013-06-28 14:39 738http://www.ibm.com/developerwo ... -
Wicket Struts 比较
2013-06-24 17:04 852转自http://tech.ccidnet.com/a ... -
tomcat 源码学习
2012-11-14 15:08 2524Tomcat从5.5版本开始,支持以下四种Connect ... -
ibatis 总结
2012-11-14 15:09 1449ibatis的jdbctype和ENDDATE=&quo ... -
servlet 总结
2012-11-14 15:08 8921、web原理与规范_____________________ ...
相关推荐
Spring总结
包含Spring简介,AOP,SpringMVC,集成JDBC,事务,ORM框架,Spring集成知识点总结,以思维导图的形式展示,xmind文件。
标题中的“spring总结”指的是对Spring框架的全面回顾和总结,Spring是Java开发中最广泛应用的轻量级框架,尤其在企业级应用开发中占据主导地位。这篇总结可能涵盖了Spring的核心特性、工作原理以及最佳实践。 描述...
Spring个人总结,基于Annotation注解的方式开发,配置
spring总结1可以查看
三大框架里的spring总结,希望对各位有用。
spring入门笔记
在这个“狂神说”系列的Spring源码总结中,我们可以深入理解Spring的核心概念和实现机制。 1. **依赖注入(DI)与控制反转(IoC)**:Spring的核心特性是依赖注入,它通过反转应用程序对对象的控制权,使得对象的创建和...
【总结】 Spring 框架是一个全方位的解决方案,它不仅提供了一种管理对象生命周期和依赖关系的有效方式,还简化了事务处理、持久层操作和Web应用的开发。通过使用Spring,开发者可以构建出更加模块化、易于测试和...
【Spring 框架概述】 Spring 是一个广泛应用于企业级 Java 开发的开源框架,由 Rod Johnson 创建,旨在简化 Java EE 应用的复杂性。它以轻量级、低侵入式的设计理念,提供了全面的解决方案,涵盖从表现层到业务逻辑...
Spring5思维导图
文章目录Spring总结Spring容器控制反转(IoC)基于XML的IoC Spring总结 Spring容器 什么是Spring容器 从概念上讲:Spring 容器是 Spring框架的核心,是用来管理对象的。容器将创建对象,把它们连接在一起,配置它们...
spring方面介绍 常用注解 生命周期 AOP DI
### Spring框架概述与基本配置 #### 一、Spring框架简介 Spring框架是一个开源的企业级Java应用框架,由Rod Johnson创建并由Pivotal Software提供支持。Spring提供了全面的基础架构支持,使得开发者能够专注于应用...
Spring框架是Java开发中最广泛应用的轻量级框架之一,它以其IoC(Inversion of Control,控制反转)和AOP(Aspect Oriented Programming,面向切面编程)为核心特性,极大地简化了企业级应用的开发。这份"Spring思维...