第一讲 Spring简介

一、Spring：春天 --- 给软件行业带来了春天。由Rod Johnson创建。

二、理念：使现有技术更加实用。本身是大杂烩，整合现有的框架技术。

三、Spring优点：

     轻量级框架

      IoC容器：控制反转

     AOP：面向切面编程

     对事务的支持

     对框架的支持

     ...

四、主要内容

五、IoC --- Inversion of Control（控制反转）

      案例1：

public interface UserDao {             public void getUser();       }

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

public class UserDaoOracleImpl implements UserDao {       public void getUser() {            System. out .println( "oracle获取用户数据" );      } }

public interface UserService {             public void getUser();       }

public class UserServiceImpl implements UserService { //   private UserDao userDao = new UserDaoMySqlImpl();       privateUserDaouserDao= null;            publicvoidsetUserDao(UserDaouserDao) {            this.userDao=userDao;      }             public void getUser() {             userDao .getUser();      }       }

public class Test {       public static void main(String[] args ) { //         UserService userService = new UserServiceImpl(); //         userService.getUser();            UserServiceImpl userService = new UserServiceImpl();             userService .setUserDao( new UserDaoMySqlImpl());             userService .getUser();            System. out .println( "----------------" );             userService .setUserDao( new UserDaoOracleImpl());             userService .getUser();      } }

例如现在用MySql写了一个程序，但是用了一段时间以后，由于需要，要改用为Oracle。怎么办呢？如果按照以前的方法，新写一个    OracleDao以后，以前用到MySqlDao的地方全部都要改为使用OracleDao。这样整个程序不仅改的地方多，而且还要重新编译。但    是如果通过IoC的方式就不需要再改变原有代码了，只需要在使用的地方去接收需要的对象就好了。而且这个需要的对象可以通过配置    文件来创建，这样原有代码就不需要做任何修改了。

      通过案例1：

          对象由原来程序本身创建，变为了程序接收对象。

          程序员主要精力集中于业务实现。

          实现了service和dao的解耦工作。service层和dao层实现了分离。没有直接依赖关系。

          如果dao的实现发生改变，应用程序本身不用改变。

     案例1使用spring来实现：（加上beans.xml修改Test.java）

<? xml version = "1.0" encoding = "UTF-8" ?> < beans xmlns = "http://www.springframework.org/schema/beans"       xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"       xsi:schemaLocation = "http://www.springframework.org/schema/beans      http://www.springframework.org/schema/beans/spring-beans.xsd" >       < bean id = "userDaoMySql" class = "com.liujie.dao.impl.UserDaoMySqlImpl" ></ bean >       < bean id = "userDaoOracle" class = "com.liujie.dao.impl.UserDaoOracleImpl" ></ bean >       < bean id = "userService" class = "com.liujie.service.impl.UserServiceImpl" >             <!-- ref引用对象（对象是由spring来创建的） -->             < property name = "userDao" ref = "userDaoOracle" ></ property >             <!-- name="userDao"会去寻找userDaoOracle（即UserDaoOracleImpl）里面的getUserDao方法赋值 -->       </ bean >       </ beans >

public class Test {       public static void main(String[] args ) {             //解析beans.xml文件，生成管理相应的bean对象            ApplicationContext context = new ClassPathXmlApplicationContext( "beans.xml" );                        UserService userService =(UserService) context.getBean("userService" );             userService .getUser();      } }

六、Hello Spring

步骤：             导入相关jar包            编写spring配置文件（名称可以自定义）

      导入jar包

            < dependency >

                 < groupId > javax.servlet </ groupId >

                 < artifactId > javax.servlet-api </ artifactId >

                 < version > 3.0.1 </ version >

                 < scope > provided </ scope >

            </ dependency >

            < dependency >

                 < groupId > org.springframework </ groupId >

                 < artifactId > spring-webmvc </ artifactId >

                 < version > 4.2.1.RELEASE </ version >

            </ dependency >

            < dependency >

                 < groupId > javax.servlet </ groupId >

                 < artifactId > jstl </ artifactId >

                 < version > 1.2 </ version >

            </ dependency >

      Hello.java

public class Hello {

     

      //用来检查spring是否创建了Hello对象

      public Hello() {

           System. out .println( "hello，被创建" );

     }

      private String name ;

     

      public void setName(String name ) {

            this . name = name ;

     }

     

      public void show() {

           System. out .println( "hello," + name );

     }

     

}

      beans.xml

<? xml version = "1.0" encoding = "UTF-8" ?>

< beans xmlns = "http://www.springframework.org/schema/beans"

      xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"

      xsi:schemaLocation = "http://www.springframework.org/schema/beans

     http://www.springframework.org/schema/beans/spring-beans.xsd" >

      <!-- bean就是java对象，由spring容器来创建和管理 -->

     <!-- name值可以自定义 -->

      < bean name="hello" class = "com.liujie.bean.Hello" >

            < property name = "name" value = "spring" />

      </ bean >

     

</ beans >

      测试代码

public class Test {

      public static void main(String[] args ) {

            //解析beans.xml文件，生成管理相应的bean对象

           ApplicationContext context=newClassPathXmlApplicationContext("beans.xml");

           Hello hello = (Hello) context .getBean( "hello" );

            hello .show();

     }

}

思考？           Hello对象是谁创建的？           Hello对象属性是怎么设置的？

Hello对象是由spring容器创建的。           Hello对象属性是由spring容器来设置的。    这个过程就叫 控制反转：     控制的内容：指谁来控制对象的创建。传统的应用程序对象的创建是由程序本身来控制的。使用spring后，是由spring来创建对                      象的。     反转：正转，指程序来创建对象。反转，指程序本身不去创建对象，而变为被动地接收对象。

总结：以前对象是由程序本身来创建，使用spring后，程序变为被动接收spring创建好的对象。

控制反转 --- 依赖注入（Dependency Injection，通过setter方法来进行注入的）

IoC --- 是一种编程思想。由主动编程变为被动接收。

      IoC的实现是通过IoC容器来实现的。IoC容器 --- BeanFactory

BeanFactory context = new ClassPathXmlApplicationContext( "beans.xml" ); ApplicationContext context = new ClassPathXmlApplicationContext( "beans.xml" );

BeanFactory是ApplicationContext的一个父类。