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:
ApplicationContext app= new ClassPathXmlApplicationContext("applicationContext.xml");
HelloSpring hello= (HelloSpring)app.getBean("hello");
bean实例化的三种方式:
（1）使用类的无参数构造创建
（2）静态工厂
（3）实例工厂创建
xml配置Bean-----依赖注入方式
1、属性注入：
属性注入即通过setter方法注入Bean的属性值或依赖的对象
属性注入使用元素，使用name属性指定bean的属性名称，value属性或子节点指定属性值
2、构造器注入：
通过构造方法注入bean的属性值或依赖的对象，它保证了bean实例在实例化后就可以使用
构造器注入在元素里声明属性，常用属性：name,value,type
3、接口方法注入（很少使用，不推荐）
引用Bean：
p:名称空间注入
xmlns:p="http://www.springframework.org/schema/p"
使用注解配置：
组件扫描：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;
@Autowired
public 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、业务模块更简洁，只包含核心业务代码
使用动态代理解决问题：
使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上
切面：带有@Aspect注解的java类
通知：是标注有以下5种注解的简单的java方法
@Before:前置通知，在方法执行之前执行
@After:后置通知，在方法执行之后执行
@AfterRunning:返回通知，在方法返回结果之后执行
@AfterThrowing:异常通知，在方法抛出异常之后
@Around:环绕通知，围绕着方法执行
第一种方法：
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;
}
}@Aspect
public 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的哪种事务管理策略，事务管理器都是必须的。
@Service("bookService")
@Transactional
public class BookServiceImpl implements BookService {
@Autowired
private BookDao bookDao;
@Autowired
private UserDao userDao;
public String buyBook(String bookId, String userId,int count) {
// TODO Auto-generated method stub
Book book=bookDao.selectById(bookId);
User user=userDao.selectById(userId);
if(book.getAmount()0) {
book.setAmount(book.getAmount()-count);
count2=bookDao.update(book);
}
if(count2>0) {
return "购买成功";
} else {
return "购买失败";
}
}
}
@Override
public String addBook(String bookId, int count) {
// TODO Auto-generated method stub
Book book=bookDao.selectById(bookId);
book.setAmount(book.getAmount()+count);
int count1=bookDao.add(book);
if(count1>0){
return "添加成功";
}else{
return "添加失败";
}
}
@Override
public String deleteBook(String bookId) {
// TODO Auto-generated method stub
int count1=bookDao.delete(bookId);
if(count1>0){
return "删除成功";
}else{
return "删除失败";
}
}
}