- 浏览: 251095 次
- 性别:
- 来自: 北京
-
文章分类
- 全部博客 (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 2523Tomcat从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思维...