初始Spring

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!--spring对应的版本号-->
        <spring.version>4.2.1.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.0</version>
            <scope>test</scope>
        </dependency>

        <!--引入需要的spring 核心jar-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.1</version>
        </dependency>

        <!--引入mysql的驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.26</version>
        </dependency>

        <!--配置jdbc需要的数据源-->
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.6</version>
        </dependency>

        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>

        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

        <!--SpringJDBC需要的jar-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--aspectj需要的jar-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>
        <!--spring整合aspect需要的jar-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--引入spring需要的事务jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>


</dependencies>

1.Spring(容器)的特点：

　　概念：spring是J2EE应用程序框架，是轻量级的IoC和AOP的容器框架，主要是针对javaBean的生命周期进行管理的轻量级容器，可以单独使用，也可以和Struts框架，ibatis框架等组合使用。

　　01.大大的简化了程序员所编写的代码量

　　02.使用IOC来降低主业务之间的耦合度

　　03.使用AOP来降低主业务和系统级业务之间的耦合度

　　04.这是一款非侵入式的框架

　　　　说到侵入式，那让我们来谈谈什么是侵入式和非侵入式，简单来说：

　　　　　　侵入式：我们如果要实现某个功能，必须继承或实现某些类或接口，那么这就是侵入式。

　　　　　　非侵入式：我们不需要显示的继承或实现某些类或接口，这就是非侵入式。

　　05.这是一款一站式开发框架：

　　　　把许多功能集成在了一起，比如Struts2，Spring MVC，HiberNate，JDBC等。

 

2.Spring核心：

　　1.Spring容器：

　　　　01.负责创建项目中所有的对象（bean）

　　　　02.管理对象之间的各种关系

　　　　03.Spring的核心配置文件

　　2.IOC：（Inversion  Of  Control,控制反转）

　　　　在service层创建出dao层的实例对象，控制权在service，这样既不安全，有耦合。现在把控制权交给Spring容器，这个行为叫做控制反转。

　　　　ID（Dependency  Injection，依赖注入）

　　　　　　service层的new XxxdaoImpl()被删除，dao的对象是Spring容器创建的。Spring容器把创建dao层对象通过setdao()注入到对象中，这个过程就是依赖注入。DI是IOC的一种具体实现

　　2.AOP：（Aspect Oriented Programing,面向切面编程）

　　　　01.其底层是动态代理设计模式

　　　　02.切面（Aspect）：系统级业务，对主业务进行增强的方法

　　　　03.切入点：把系统级业务植入到主业务上，主业务方法叫做切入点

　　　　04.连接点（JoinPoint）：所有的主业务方法

　　　　05.植入（Weaving）：把系统级业务放到主业务上的过程

　　　　06.目标对象:（Target）调用主业务对象

　　　　　　StudentDao stu=new StudentDaoImpl();

　　　　　　stu就是目标对象

　　　　07.顾问：（Advisor）是切面的一种体现，定义了植入的时间与位置

　　　　08.通知：（Advice）是切面的一种实现，定义了植入的时间。通知书顾问的一个属性，顾问包含通知

3.Spring体系图

 

 4.Spring入门案例：

　　1.实体类：

public class Student implements Serializable{

    private int sid;
    private int age;
    private String sname;

    public Student() {
    }

    public Student(int sid, int age, String sname) {
        this.sid = sid;
        this.age = age;
        this.sname = sname;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", age=" + age +
                ", sname='" + sname + '\'' +
                '}';
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }
}

 

　　2.dao层：

public interface UserDao{

    int add(Student student);//新增

    int update(Student student);//修改

    int delete(Serializable id);//删除

    List<Student> findAll();//查询全部

}

　　3.daoImpl层

public class UserDaoImpl extends JdbcDaoSupport implements UserDao {


    @Override
    public int add(Student student) {
        String sql="INSERT INTO student (sname,age)VALUES(?,?)";
        return getJdbcTemplate().update(sql,student.getSname(),student.getAge());
    }

    @Override
    public int update(Student student) {
        String sql="UPDATE student SET sname=? where sid=?";
        return getJdbcTemplate().update(sql,student.getSname(),student.getSid());
    }

    @Override
    public int delete(Serializable id) {
        String sql="delete from student where sid=?";
        return getJdbcTemplate().update(sql,id);
    }

    @Override
    public List<Student> findAll() {
        String sql="select * from student";
        return getJdbcTemplate().query(sql, new RowMapper<Student>() {//匿名内部类
            @Override
            public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
                System.out.println("*************************");
                Student s=new Student();
                s.setSid(rs.getInt("sid"));
                s.setSname(rs.getString("sname"));
                s.setAge(rs.getInt("age"));
                return s;
            }
        });
    }
}

 

　　4.service层

public interface UserService {

    int add(Student student);

    int update(Serializable id);

    int delete(Student student);

    List<Student> findAll();
}

　　5.serviceImpl层

public class UserServiceImpl implements UserService{


    @Override
    public int add(Student student) {
        return 0;
    }

    @Override
    public int update(Serializable id) {
        return 0;
    }

    @Override
    public int delete(Student student) {
        return 0;
    }

    @Override
    public List<Student> findAll() {
        return null;
    }
}

　　6.测试类

 

public class App {

    UserDao dao=null;
    Testvalue testvalue=null;
    @Before
    public void before(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Spring-jdbc.xml");
        dao=context.getBean(UserDao.class);
        testvalue=context.getBean(Testvalue.class);
    }

    /**
     * 添加
     */
    @Test
    public void add(){
        Student student=new Student();
        student.setSname("wwww");
        student.setAge(6);
        dao.add(student);
    }

    /**
     * 修改
     */
    @Test
    public void update(){
        Student student=new Student();
        student.setSname("aaa");
        student.setSid(15);
        dao.update(student);
    }

    /**
     * 删除
     */
    @Test
    public void delete(){
        Student student=new Student();
        dao.delete(16);
    }

    /**
     * 查询
     */
    @Test
    public void select(){
        List<Student>list=dao.findAll();
        for (Student stu:list) {
            System.out.println(stu);
        }
    }

    @Test
    public void values(){
        String value=testvalue.getYzwname();
        System.out.println(value);

    }
}