spring的使用-基本使用

Posted 2021-01-20 liuxuelin

1.spring介绍

       Spring它是一个一站式的分层轻量级框架

       spring 优点：

              1)方便解耦，简化开发

              2)AOP 编程的支持

              3)声明式事务的支持

              4)方便程序的测试

              5)方便集成各种优秀框架

              6)降低 JavaEE API 的使用难度

 

2.开发环境搭建：---ioc di

       jar包：beans,core,context,spel（spring-expression）四个相关jar包，日志包（1个）（commons-logging），dom4j包（1个）

       配置文件：

              applicationContext.xml

              约束的获取：xsd-configuration.html--based configuration

 

3.ioc :inverse of contral(控制反转)和DI（依赖注入）   

       ioc：

              需要对象时，不是自己创建，由工厂创建，即将对象创建的权力交给spring容器

              原理：配置文件（统一管理bean）+工厂-->dom解析+反射

              实现步骤：

                     1)applicationContext.xml中配置bean：

                            <bean id="userService" class="cn.itheima.ioc.UserServiceImpl"></bean>

                            class:为bean的全类名

                            id：也可以写name配置文件中。id 和name区别,id遵守xml规范，不能包含特殊符号

                     2)通过AppliCationContext对象获取userService   

                            ApplicationContext applicationContext =new ClassPathXmlApplicationContext("applicationContext.xml");  //在classpath路径下查找applicationContext.xml配置文件，并解析，

                                                                                                                                                                                                                  //同时根据全类名，通过反射技术创建对象并将对象放入工厂中，注意，前提：scope="singleton"

                            IUserService userService = (IUserService) applicationContext.getBean("userService");      //从工厂对象中获取对象，字符串为xml文件中的id或name

                            userService.sayHello();  //调用对象的方法

                    

                     3)两个ApplicationContext的实现类

                            ClassPathXmlApplicationContext //根据类路径查找，默认会在src下查早--applicationContext.xml

                            FilePathXmlApplicationContext  //根据文件路径获取，默认在工程路径下查找--src/applicationContext.xml

       DI    //dependency injection 依赖注入

              属性注入的方式：      //在配置文件中配置，实现bean属性的赋值：

                     1.使用构造方法实现属性注入    //需要在bean中提供带参构造

                            <bean id="car" class="cn.itheima.di.Car">

                                   <constructor-arg index="0" value="奔弛"/>          //index指定参数，0表示第一个参数，依次类推，value为参数值

                                   <constructor-arg index="1" value="1000000"/>

                            </bean>

                           

                     2.使用setter方法实现属性注入 //需要有无参构造

                            <bean id="person" class="cn.itheima.di.Person">

                                   <property name="name" value="张三" />      //name指定对应的set方法，value为参数值，注意：name 首字母不区分大小写，后面的字母区分大小写

                                   <property name="car" ref="car1" />        //ref引用其它bean的id或name值，会传入一个car对象

                            </bean>

 

                            配置文件加载后，会创建对象，并调用指定的set方法，给参数赋值

                           

                     注意：集合或数组类型的注入：

                            <!-- 集合属性注入 -->

                            <bean id="collectionDemo" class="cn.itheima.di.CollectionDemo">

                            <property name="Orderlist">           //list集合或数组属性注入,这里的name也是对应的set方法

                                    <list>

                                          <value>张三</value>

                                          <value>10</value>

                                          <ref bean="car" />      //ref引用其它bean的id或name值，会传入一个car对象

                                     </list>

                            </property>

                            <property name="set">

                                     <set>

                                          <value>10</value>

                                          <value>李四</value>

                                          <ref bean="person" />

                                     </set>

                            </property>

                            <property name="map">

                                      <map>

                                            <entry key="username" value="李四"></entry>

                                            <entry key-ref="person" value-ref="car"></entry>

                                      </map>

                            </property>

                            <property name="props">        //properties集合属性的注入

                                      <props>

                                            <prop key="company">ITCAST</prop>

                                            <prop key="price">10000</prop>

                                      </props>

                            </property>

                            </bean>

                     4.采用-c与p名称空间实现属性注入             //它们不是真正的名称空间，是虚拟的。它是嵌入到spring内核中的。，可简化属性注入

                            使用p名称空间可以解决我们setter注入时<property>简化      //需要加虚拟名称空间：xmlns:p="http://www.springframework.org/schema/p"

                            使用c名称空间可以解决我们构造器注入时<constructor-arg>简化   //需要加虚拟名称空间：xmlns:c="http://www.springframework.org/schema/c"

                            <bean id="dog1" class="cn.itheima.namsapce.Dog" p:name="博美" p:color="白色"></bean>   //name,color指定set方法

                            <bean id="dog2" class="cn.itheima.namsapce.Dog" c:name="大丹" c:color="黑色"></bean>    //name,color为构造方法中的参数

                            <bean id="person" class="cn.itheima.namsapce.Person" p:name="张三" p:dog-ref="dog2" p:age="20"/> //dog-ref，会匹配id 和name,获取对象给参数赋值

 

 

 

       ioc和di的区别： ---所站的角度不同

              1. IOC: Spring统一管理应用程序运行时所需要的资源（站在spring角度）

              2. DI ：应用程序运行时所需要的资源由Spring来提供（站在程序角度）

              3. 站在Spring的角度就是IOC, 站在应用程序的角度就是DI, IOC是DI的前提

              4. 应用程序能够向一个对象进行DI注入的前提是：所注入资源要在Spring的管理中; 这个对象也要在Spring管理中

 

4.BeanFactory和ApplicationContext的区别：

       1. ApplicationContext扩展了BeanFactory接口

       2. ApplicationContext实例化bean采用的立即策略，即配置文件加载时就创建；BeanFactory实例化bean采用的延迟策略，只有getBean的时候才会实例化bean对象 //前提：scope="singleton"

             

             

5.作用域：scope  //在bean标签配置

       <bean id="userService" class="cn.itheima.ioc.UserServiceImpl" scope="singleton">

              <property name="info" value="ITCAST"></property>

       </bean>

              在bean声明时它有一个scope属性，它是用于描述bean的作用域有4个取值：

                     singleton(默认值):单例 代表在springioc容器中只有一个Bean实例,在配置文件加载时就创建对象（applicationContext）

                     prototype：多例 每一次从spring容器中获取时，都会返回一个新的实例，配置文件加载时不创建对象，调用getBean()时，创建

                     request 用在web开发中，将bean对象request.setAttribute()存储到request域中

                     session 用在web开发中，将bean对象session.setAttribute()存储到session域中

                     在开发中常用的值是singleton与prototype

6.springBean生命周期介绍

       a. 在bean对象创建时会执行初始化方法，在bean销毁时（ApplicationContext关闭时候），执行销毁得方法

              <bean id="beanLifeCycle" class="cn.itheima.bean.BeanLifeCycle"

                     init-method="myInit" destroy-method="myDestroy">  //此处配置了初始化方法和销毁方法，参数为方法名称

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

              </bean>

 

              myDestroy在bean销毁时（ApplicationContext关闭时候）调用 //前提：scope必须为singleton，如果为prototype，bean不由ApplicationContext管理，

                                                                                                                       在ApplicationContext关闭时不会销毁bean,不执行myDestroy方法

                                                                                                                                                         

       b. bean内部获取bean的id，ApplicationContext

              bean实现BeanNameAware接口通过setBeanName(String nameId)获取bean的id或name值           //获取id或name

              bean实现ApplicationContextAware接口通过setApplicationContext(ApplicationContext arg0)获取ApplicationContext                 //获取ApplicationContext     

              Bean实现InitializingBean接口，afterPropertiesSet属性注入之后调用      //可用来替代注解，定义初始化方法

              Bean实现DisposableBean接口，destroy方法在ApplicationContext--->close的时候调用   //可用来替代注解，定义销毁方法

 

       c.bean后处理方式实现bean的增强：

              1.创建一个类BeanPostProcessor实现BeanPostProcessor接口  

              2.在类中创建代理对象实现功能增强

             

              3.在ApplicationContext.xml中配置这个类：

                     <bean class="cn.itheima.bean.MyBeanPostProcess"></bean>            //将这个类交给工厂管理

             

              做完以上三步后，当工厂对象初始化bean，并完成属性注入后，bpp对象因为实现了BeanPostProcessor，会提前获取到初始化的bean对象,并调用postProcessBeforeInitialization

             

       d. 总结：                   

              1.    instantiate bean对象实例化

              2.    populate properties 封装属性

              3.    如果Bean实现BeanNameAware执行setBeanName

              4.    如果Bean实现BeanFactoryAwar或ApplicationContextAwar，会设置工厂setBeanFactory或上下文对象setApplicationContext

              5.    如果存在类实现BeanPostProcessor(后处理Bean),执行postProcessBeforeInitialization  

              6.    如果Bean实现InitializingBean执行afterPropertiesSet

              7.    调用自定义的init-method方法

              8.    如果存在类实现BeanPostProcessor(处理Bean),执行postProcessAfterInitialization

              9.    执行业务处理

              10.  如果Bean实现DisposableBean执行destroy

              11.  调用自定义的destroy-method

                                                                                                               

                                                                                                               

 

7.注解开发，简化配置：--注解实现对象的管理，属性的注入                                                                                                     

       1. 导入aop的spring-jar包                                                                                                       

       2. applicationcontext.xml中引入context的名称空间

       3. 开启注解扫描：

              <context:component-scan base-package="cn.itheima" />   //base-package指定spring扫描的包

              这个配置作用是指定spring扫描的包,它包含了context:annotation-config的功能(让spring中常用的一些注解生效)

             

       4. 在需要被ioc(Spring管理)的类上配置@Component

              @Component("userService")      //括号中设置id或name,默认值为类名的首字母小写

              public class UserServiceImpl implements IUserService {

                    

                     在spring2.5后为@Component添加了三个衍生的注解，他们的作用与@Component一样，只起到标记作用

                     @Repository 用于DAO层

                     @Service 用于service层

                     @Controller  用于表现层

                    

       5. 注解实现属性的注入      //注解可以写在对应的Set方法上

              @Value("张三")

              private String name;     //为类中的成员变量，不需要提供set方法

 

              @Autowired         //此时会根据成员变量的类型，获取其唯一实现类的对象，并赋值

              private IUserDAO userDao;

             

              @Autowired         //如果实现类不只有一个，需要在加一个注解，指定实现类：或者采用@resource注解

              @Qualifier("userDao")

              private IUserDAO userDao;

             

              @Resource(name="userDao")    //不指定name,则等同于@Autowired

              private IUserDAO userDao;

 

       6. 其他注解

              @Scope("prototype") @Scope它以描述bean的作用域

              @PostConstruct相当于init-method=”mInit”

              @PreDestroy 相当于是destroy-method=”mDestroy”

              注意：对于销毁的方法它只对bean的scope=singleton有效

                     @Service("userService")

                     @Scope("prototype")

                     public class UserServiceImpl implements IUserService {

                            public UserServiceImpl() {

                                         

                                   System.out.println("构造了UserServiceImpl对象");

                            }

 

                            @PostConstruct

                            public void mInit() {            

                                   System.out.println("Bean初始化");

                            }

                            @PreDestroy

                            public void mDestroy() {

                                   System.out.println("Bean销毁");

                            }

                     }

 

8.spring在web开发中应用

       1. 导入spring-web-4.2.4.RELEASE.jar

       2. 在web.xml文件中配置Listener，并指定applicationContext.xml文件的位置

              <context-param>       //配置一个全局变量，指定applicationContext.xml所在的位置

                     <param-name>contextConfigLocation</param-name>

                     <param-value>classpath:applicationContext.xml</param-value>

              </context-param>

              <listener>     //servletContext监听器

                     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

              </listener>

             

              ContextLoaderListener 实现了 ServletContextListener。在这个 listener 中，当服务器启动时，创建WebApplicationContext，加载配置文件,并将工厂对象存入到了ServletContext 中

 

       3. 获取  工厂对象：WebApplicationContext

              ServletContext servletContext = ServletActionContext.getServletContext(); //通过servletContext域对象获取

 

              WebApplicationContext webApplicationContext = (WebApplicationContext) servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

 

              ContextLoaderListener解决了什么问题:

                     在tomcat启动的时候通过WebApplicationContext加载applicationContext.xml配置文件，所以在web应用中就不需要在手动的构造一个ClassPathXmlApplicationContext去加载applicationContext.xml配置文件了