Spring学习笔记--Spring简介

1.spring:给软件行业带来了春天;

2.spring的理念：spring框架的初衷是使的现有的更加实用，spring不是创造轮子(技术或框架)，而是使现有的轮子更好的运转;spring本身是一个大杂烩，整合现有的框架技术；

3.Spring优点：

　　轻量级框架：不具备侵入性(使用某个框架，我们不需要实现它的某个接口，方便框架的替换，原有的代码不需要替换);

　　Ioc容器：控制反转;

　　Aop：面向切面编程;

　　对事务的支持；

　　对矿建的支持;

　　...................

4.主要内容：

从下向上看spring的主要内容：

Test：Spring支持Junit单元测试

核心容器(IOC)：Bean(Bean工厂，创建对象)、Core(一切的基础)、Context(上下文)、SpEL(Spring的表达式语言);

AOP：AOP、Aspects

对数据访问的支持:JDBC、ORM、Transaction、JMS(java邮件服务)

对web的支持：Spring MVC

5.Ioc--inversion of control控制反转:

首先引用一篇文章的内容，简单了解一下DAO和Service层，Controller层、View层(http://www.jianshu.com/p/403acf6df656)，另一篇文章http://www.cnblogs.com/xdp-gacl/p/4249939.html对Spring IOC设计思想的总结比较全面和通俗易懂;

1、Dao层
Dao层主要是做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此，Dao层的设计首先是设计Dao的接口，然后在Spring的配置文件中定义此接口的实现类，然后就可在模块中调用此接口来进行数据业务的处理，而不用关心此接口的具体实现类是哪个类，显得结构非常清晰，Dao层的数据源配置，以及有关数据库连接的参数都在Spring的配置文件中进行配置。

2、Service层
Service层主要负责业务模块的逻辑应用设计。同样是首先设计接口，再设计其实现的类，接着再Spring的配置文件中配置其实现的关联。这样我们就可以在应用中调用Service接口来进行业务处理。Service层的业务实现，具体要调用到已定义的Dao层的接口，封装Service层的业务逻辑有利于通用的业务逻辑的独立性和重复利用性，程序显得非常简洁。

3、Controller层
Controller层负责具体的业务模块流程的控制，在此层里面要调用Service层的接口来控制业务流程，控制的配置也同样是在Spring的配置文件里面进行，针对具体的业务流程，会有不同的控制器，我们具体的设计过程中可以将流程进行抽象归纳，设计出可以重复利用的子单元流程模块，这样不仅使程序结构变得清晰，也大大减少了代码量。

4、View层 
View层与控制层结合比较紧密，需要二者结合起来协同工作。View层主要负责网页前台的Jsp页面的表示。

文／睡在客厅里的人（简书作者）
原文链接：http://www.jianshu.com/p/403acf6df656
著作权归作者所有，转载请联系作者获得授权，并标注“简书作者”。

鉴于上面文章中的介绍我们首先给出IOC(控制反转)思想的代码示例:

第一步：定义DAO接口UserDao

package cn.sxt.dao;
//降低耦合性
public interface UserDao {
    public void getUser();
}

第二步：定义DAO接口的实现类UserDaoMysqlImpl和UserDaoOracleImpl
UserDaoMysqlImpl:

package cn.sxt.dao.impl;

import cn.sxt.dao.UserDao;

public class UserDaoMySqlImpl implements UserDao {
    @Override
    public void getUser(){
        System.out.println("mysql获取用户数据");
    }
}

UserDaoOracleImpl:

package cn.sxt.dao.impl;

import cn.sxt.dao.UserDao;

public class UserDaoMySqlImpl implements UserDao {
    @Override
    public void getUser(){
        System.out.println("mysql获取用户数据");
    }
}

第三步:定义Service层接口UserService，实现具体的业务

package cn.sxt.service;

public interface UserService {
    public void getUser();
}

第四步:定义Service接口的实现类UserServiceImpl,Service层的业务实现，具体要调用到已定义的Dao层的接口

我们传统的JavaSe设计思想，代码是这样组织的：我们直接在对象内部(应用程序本身)通过new进行创建对象，是程序主动去创建依赖对象

package cn.sxt.service.impl;

import cn.sxt.dao.UserDao;
import cn.sxt.service.UserService;

public class UserServiceImpl implements UserService{
    //直接依赖(耦合)
    private UserDao userDao=new UserDaoMySqlImpl();
    @Override
    public void getUser(){
        userDao.getUser();
    }
}

在我们的测试类Test(可以理解成客户端)中

package cn.sxt.test;

import cn.sxt.dao.impl.UserDaoMySqlImpl;
import cn.sxt.dao.impl.UserDaoOracleImpl;
import cn.sxt.service.impl.UserServiceImpl;

//原来是在UserServiceImpl中创建Userdao对象(应用程序本身)
//现在是客户端(调用端)来创建
public class Test {
    public static void main(String args[]){
    UserServiceImpl userService=new UserServiceImpl();
    userService.getUser();
}

如果需要替换DAO接口的具体实现类的时候，我们需要将UserServiceImpl中的

private UserDao userDao=new UserDaoMySqlImpl();

修改为：

private UserDao userDao=new UserDaoOracleImpl();

控制反转(IOC)的设计思想，我们不需要应用程序本身来创建对象，而是将创建对象的任务交付给IOC容器：此时，我们在UserServiceImpl可以这样编写代码

package cn.sxt.service.impl;

import cn.sxt.dao.UserDao;
import cn.sxt.service.UserService;

public class UserServiceImpl implements UserService{
    //直接依赖(耦合)
            //    private UserDao userDao=new UserDaoMySqlImpl();
    //瞬间隔离开来
    private UserDao userDao=null;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void getUser(){
        userDao.getUser();
    }
}

添加一个set方法，当调用端需要创建对象的时候，创建具体实现类的对象,此时我们在Test类中就可以这样组织代码：

package cn.sxt.test;

import cn.sxt.dao.impl.UserDaoMySqlImpl;
import cn.sxt.dao.impl.UserDaoOracleImpl;
import cn.sxt.service.impl.UserServiceImpl;

//原来是在UserServiceImpl中创建Userdao对象(应用程序本身)
//现在是客户端(调用端)来创建
public class Test {
    public static void main(String args[]){
        UserServiceImpl userService=new UserServiceImpl();
        userService.setUserDao(new UserDaoMySqlImpl());
        userService.getUser();
        System.out.println("-----分割线------");
        userService.setUserDao(new UserDaoOracleImpl());
        userService.getUser();

    }
}

Test测试类运行结果：

mysql获取用户数据
-----分割线------
Oracle获取用户数据

　  通过上面的例子：

1).对象由原来程序本身创建，变为了程序接收对象
 2).程序员主要精力集中与业务的实现
 3).实现了service和dao的解耦工作,没有直接依赖关系,层与层之间实现了分离(service和DAO没有关系，完全分离)
 4).如果dao的实现发生改变，应用程序本身不用改变(更改Spring的配置文件)