spring框架

spring框架：

轻量级框架，javaEE的春天，当前主流框架

目标：

使现有技术更加易用，推进代码最佳实践

内容：

1、依赖注入容器

2、web集成

3、数据访问支持

4、简化Hibernate编码

5、声明式事务

6、AOP实现

IOC和DI:

IOC:其思想是反转资源获取的方向。传统的资源查找方式要求组件向容器发起请求查找资源。作为回应，容器实时的返回资源。而应用了IOC之后，则是容器主动地将资源推送给他所管理的组件，组件所要做的仅是选择一种合适的方式来接受资源。这种行为也被称为查找的被动形式

DI（依赖注入）----IOC的另一种表述方式：即组件以一些预先定义好的方式接受来自容器的资源注入，相对于IOC而言，这种表述更直接

为什么使用依赖注入（DI）：

1、组件化的思想：分离关注点

2、依赖注入，强制将组件的构建和使用分开

IOC的操作：

1、把对象的创建交给spring进行管理

2、IOC操作两部分：

（1）IOC的配置文件

（2）IOC的注解

IOC底层原理：

IOC底层原理使用技术

（1）xml配置文件

（2）dom4j解决xml

（3）工厂设计模式

（4）反射

Spring容器：

在xml文件中通过bean节点来配置bean

在Spring IOC 容器读取 Bean 配置创建Bean实例之前，必须对它进行实例化。只有在容器实例化后，才可以从IOC容器获取Bean实例并使用

Spring提供了两种类型的IOC容器实现

1、BeanFactory:IOC容器的底层基本实现

2、ApplicationContext:提供了更多的高级特性。是BeanFactory的子接口

配置Bean基于xml:

<!-- 在IOC容器中创建HelloSpring对象 --><bean id="hello" class="com.jredu.entity.HelloSpring" scope="prototype"><!-- scope是选择是否单例模式 --><property name="name" value="奥特曼 ""/><property name="age" value="2000"/></bean>

ApplicationContext app= new ClassPathXmlApplicationContext("applicationContext.xml");HelloSpring hello= (HelloSpring)app.getBean("hello");

bean实例化的三种方式:

（1）使用类的无参数构造创建

（2）静态工厂

（3）实例工厂创建

xml配置Bean-----依赖注入方式

1、属性注入：

属性注入即通过setter方法注入Bean的属性值或依赖的对象

属性注入使用<property>元素，使用name属性指定bean的属性名称，value属性或<value>子节点指定属性值

2、构造器注入：

通过构造方法注入bean的属性值或依赖的对象，它保证了bean实例在实例化后就可以使用

构造器注入在<constructor-arg>元素里声明属性，常用属性：name,value,type

3、接口方法注入（很少使用，不推荐）

引用Bean：

通过<ref>元素或ref属性为bean的属性或构造器参数指定对bean的引用

<bean id="addr" class="com.jredu.entity.Address"><property name="name" value="花果山"/><property name="code" value="123456" /></bean><bean id="ccz" class="com.jredu.entity.Person"><property name="name" value="ccz"/><property name="address" ref="addr" /></bean>

p:名称空间注入

xmlns:p="http://www.springframework.org/schema/p"

<!--c3p0连接池配置  --><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" p:driverClass="${jdbc.driverClassname}" p:jdbcUrl="${jdbc.url}" p:user="${jdbc.user}" p:password="${jdbc.pwd}" p:initialPoolSize ="${jdbc.initPoolSize}"  p:maxPoolSize="${jdbc.maxPoolSize}"  /> <bean id="jdbcTemptate" class="org.springframework.jdbc.core.JdbcTemplate" p:dataSource-ref="dataSource" />

使用注解配置：

组件扫描：Spring 能够从classpath下自动扫描，侦测和实例化具有特定注解的组件

特定组件包括：

@Component:基本注解，标识了一个受Spring管理的组件

@Repository:标识持久层组件

@Service:标识服务层（业务层）组件

@Controller:标识控制层组件

对于扫描到的组件，Spring有默认的命名策略：使用非限定类名，第一个字母小写，也可以在注解中通过value属性值标识组件的名称

注入属性：

1、@Autowired根据类名自动注入属性

@Autowired注解自动装Bean

构造器，普通字段，一切具有参数的方法都可以应用@Autowired注解

@Autowired注解具有required属性

@Autowired注解也可以应用在数组类型的属性上

@Autowired注解也可以应用在集合属性上

@Autowired注解也可以用在java.util.Map上

2、Resource根据name值准确注入属性

@Component(value="userAction")public class UserAction {private UserService service;@Autowiredpublic void setUserService(UserService service) {this.service=service;}public void doPost(User user) {System.out.println("action user:"+user.getName());//调用业务层service.login(user);}}

Aop面向切面过程：

1、是一种新的方法论，是对传统的面向对象编程的补充

2、编程时，仍然需要定义公共功能，但可以明确的定义这个功能在哪里，以什么方式应用,并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的对象里

AOP的好处:

1、每个事物逻辑位于一个位置，代码不分散，便于维护和升级

2、业务模块更简洁，只包含核心业务代码

使用动态代理解决问题：

使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上

用AspectJ注解声明切面：

切面：带有@Aspect注解的java类

通知：是标注有以下5种注解的简单的java方法

@Before:前置通知，在方法执行之前执行

@After:后置通知，在方法执行之后执行

@AfterRunning:返回通知，在方法返回结果之后执行

@AfterThrowing:异常通知，在方法抛出异常之后

@Around:环绕通知，围绕着方法执行

第一种方法：

<bean id="scoreLogger" class="com.jredu.aop.log.ScoreLogger"/><aop:config><aop:pointcut expression="execution(public int com.jredu.aop.service.ScoreService.*(int))" id="pointcut"/><aop:aspect ref="scoreLogger"><aop:before method="beforeMethod" pointcut-ref="pointcut"/><aop:after-returning method="afterMethod" pointcut-ref="pointcut" returning="result"/><aop:around method="arroundMethod" pointcut-ref="pointcut"/></aop:aspect></aop:config>

public class ScoreLogger {public void beforeMethod(JoinPoint join){String method=join.getSignature().getName();int s=(int) join.getArgs()[0];System.out.println("----方法调用之前-------调用的方法是："+method+",方法执行前会员积分为："+s);}public void afterMethod(JoinPoint join,Object result){String method=join.getSignature().getName();System.out.println("----方法调用之后-------调用的方法是："+method+",方法执行后会员积分为："+result);}public Object arroundMethod(ProceedingJoinPoint join) throws Throwable{System.out.println("方法调用之前");Object object=join.proceed();System.out.println("方法调用之后");return object;}}

@Component(value="score")public class ScoreService {public int register(int score){return score+10;}public int addPhone(int score){return score+10;}public int addId(int score){return score+10;}public int winBid(int score){return score+50;}public int deleteEmail(int score){return score-10;}public int deletePhone(int score){return score-10;}public int deleteMessage(int score){return score-20;}}

第二种：

@Component(value="airth")public class ArithmeticService {public int add(int a,int b){return a+b;}public int sub(int a,int b){return a-b;}public int div(int a,int b){return a/b;}public int mul(int a,int b){return a*b;}}

@Aspectpublic class ArithmeticLogger {@Before("execution(public int com.jredu.aop.service.ArithmeticService.*(int,int))")public void beforeMethod(JoinPoint join){//打印调用的方法，打印方法运行前的情况String method=join.getSignature().getName();//方法名字int a=(Integer) join.getArgs()[0];int b=(Integer) join.getArgs()[1];System.out.println("----方法调用之前-------调用的方法是："+method+",方法执行前是a="+a+",b="+b);}@After("execution(public int com.jredu.aop.service.ArithmeticService.*(int,int))")public void afterMethod(JoinPoint join){//打印调用的方法，打印方法运行后的情况String method=join.getSignature().getName();//方法名字System.out.println("----方法调用之后-------调用的方法是："+method);}@AfterReturning(value="execution(public int com.jredu.aop.service.ArithmeticService.*(int,int))",returning="result")public void afterreturning(JoinPoint join,Object result){//打印调用的方法，打印方法运行后的情况String method=join.getSignature().getName();//方法名字System.out.println("----方法调用之后-------调用的方法是："+method+"结果是"+result);}    @Around(value="execution(public int com.jredu.aop.service.ArithmeticService.*(int,int))")    public Object arroundMethod(ProceedingJoinPoint join) throws Throwable{System.out.println("方法调用之前");Object object=join.proceed();System.out.println("方法调用之后");System.out.println("结果是"+object);return object;}}

Spring中的事务管理器:

spring从不同的事务管理API中抽象了一整套的事务机制，开发人员不必了解地层的事务API，就可以利用这些事务机制。有了这些事务机制，事务管理代码就能独立于特定的事务技术了。

Spring的核心事务管理是PaltformTransactionManager，她为事务管理分装了一组独立于技术的方法。无论使用spring的哪种事务管理策略，事务管理器都是必须的。

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" p:driverClass="${jdbc.driverClassname}" p:jdbcUrl="${jdbc.url}" p:user="${jdbc.user}" p:password="${jdbc.pwd}" p:initialPoolSize ="${jdbc.initPoolSize}"  p:maxPoolSize="${jdbc.maxPoolSize}"  /> <!-- 配置事务管理器 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"p:dataSource-ref="dataSource"/><!-- 开启事务注解 --><tx:annotation-driven transaction-manager="transactionManager"/><!-- 声明事务通知 --><tx:advice id="bookServiceTxAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="buyBook" propagation="REQUIRES_NEW" isolation="READ_COMMITTED"/> </tx:attributes> </tx:advice> <!-- aop面向切面配置  --><aop:config><!-- 切面接入点  --><aop:pointcut expression="execution(* com.jredu.book.service.BookService.*(..))" id="bookOperation"/> <!-- 根据切入点呼应的事务通知匹配 --> <aop:advisor advice-ref="bookServiceTxAdvice" pointcut-ref="bookOperation"/></aop:config>

@Service("bookService")@Transactionalpublic class BookServiceImpl implements BookService {@Autowiredprivate BookDao bookDao;@Autowiredprivate UserDao userDao;public String buyBook(String bookId, String userId,int count) {// TODO Auto-generated method stubBook book=bookDao.selectById(bookId);User user=userDao.selectById(userId);if(book.getAmount()<count) {return "库存数量不足";} else if(user.getMoney()<book.getPrice()*count) {return "账户余额不足";} else {//购买图书//账号扣款user.setMoney(user.getMoney()-book.getPrice()*count);int count1=userDao.update(user);int count2=0;//图书出库int i=100/0;if(count1>0) {book.setAmount(book.getAmount()-count);count2=bookDao.update(book);}if(count2>0) {return "购买成功";} else {return "购买失败";}}}@Overridepublic String addBook(String bookId, int count) {// TODO Auto-generated method stubBook book=bookDao.selectById(bookId);book.setAmount(book.getAmount()+count);int count1=bookDao.add(book);if(count1>0){return "添加成功";}else{return "添加失败";}}@Overridepublic String deleteBook(String bookId) {// TODO Auto-generated method stubint count1=bookDao.delete(bookId);if(count1>0){return "删除成功";}else{return "删除失败";}}}