Spring的第一节(Spring的基础+Spring的第一个HelloWorld+IOC+DI)

最新推荐文章于 2024-01-26 07:30:00 发布

千锋小波波

最新推荐文章于 2024-01-26 07:30:00 发布

阅读量260

点赞数 1

文章标签： Spring Spring的IOC Spring的DI Spring配置 IOC/DI

本文链接：https://blog.csdn.net/qq_24233653/article/details/80306640

版权

一:Spring是什么?

Spring是一个用来实现对象的创建以及管理对象的依赖关系的这样一门技术

对象的创建:以前的对象的创建是程序员自己 new 类名()、现在对象的创建是Spring类完成的

对象的依赖:Controll依赖于Service、Service依赖于DAO/Manager

Spring:春天意思是程序员的春天来了...

Spring家族: Spring SpringMVC Springdata SpringSecurity SpringBoot SpringCloud....

二:Spring能干什么?

1>:可以用来管理对象的创建和对象的依赖
2>:整合第三方框架
3>:给业务逻辑层提供事务

4>:提供了控制器的解决方案

三:Spring中的七大模块

Spring-Core
这个模块的主要功能实际上是用来实现IOC/DI的
Spring-AOP
提供的是面向切面编程的一些类
代理(静态代理/动态代理/cglib代理)
Spring-ORM
这个模块主要是用来整合第三方的ORM框架的(Hibernate、iBatis)
Spring-Web
这个模块实际上是Spring对web的支持
Spring-WebMVC
这个就是传说中的SpringMVC、这个模块的主要功能就是控制器的一个解决方案
Spring-DAO
这个模块是Spring用来提供的对数据库的访问的一个模块
Spring-Context
Spring中的上下文支持、UI validation mail ....

三:Spring的第一个HelloWorld程序

IOC:控制反转(针对对象的创建的)
什么东西反转了?
原来对象的创建是我们通过程序来自己完成的对象的创建就交给了Spring去完成了...
创建对象的这个权利反转了
控制:谁控制谁?
Spring控制了对象的创建
DI(依赖注入)
依赖:谁依赖于谁?
依赖于service service依赖于 DAO
注入:注入的是什么东西?

注入:注入的是依赖的对象或者数据

Spring的第一个HelloWorld程序的实现

1>:导入jar包(只需要核心功能包就可以了)

commons-logging-1.1.3.jar:这个包是Spring运行的时候所需要的日志包
spring-beans-4.3.7.RELEASE.jar:这个包是bean创建的包
spring-context-4.3.7.RELEASE.jar:这个包是Spring的上下文的包
spring-core-4.3.7.RELEASE.jar:Spring的核心功能包

spring-expression-4.3.7.RELEASE.jar:是Spring的表达式的相关包

2>:在src下面创建一个bean.xml的配置文件文件的内容如下

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
      
        <!--管理对象的创建以及对象之间的依赖关系的-->
       <!--创建用户这个对象-->
 
       <!--id:对象的名字
           class:这个类的路径 
       -->
       <bean id="user" class="com.qf.helloword.User"></bean> 
        
      </beans>

3>:编写测试程序

               //第一步:获取我们的IOC容器
	 	ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
		//第二步:获取创建好的对象
		User user=(User) context.getBean("user");
                System.out.println(user);

四:配置文件详解(IOC的配置)

1>:bean.xml配置文件的详解

 <!--管理对象的创建以及对象之间的依赖关系的-->
       <!--创建用户这个对象-->
 
       <!--id:对象的名字
           class:这个类的路径 
           scope:创建独享的时候 是单例的还是多例的
              prototype:多例的
              singleton:单例的     
           init-method:在创建这个user对象之前 执行的初始化的方法   
           destroy-method:对象要死的时候执行的方法
       -->
       <!-- <bean id="user" class="com.qf.helloword.User" scope="prototype"  destroy-method="destoryMethod" init-method="initBobo"></bean>

2>:通过工厂的形式来创建JAVA对象

1>:工厂的实现类如下:

public class UserFactory {

	/**
	 * 非静态的函数实现对象的获取
	 * @Title: getNormalInstancee 
	 * @Description: TODO
	 * @param @return    
	 * @return User    
	 * @throws
	 */
	public User getNormalInstancee(){
	   return new User();	
	}
	/**
	 * 表示的是通过静态的方法来获取对象
	 * @Title: getStaticInstance 
	 * @Description: TODO
	 * @param @return    
	 * @return User    
	 * @throws
	 */
	public static User getStaticInstance(){
		return new User();
	}
	
}

2>:bean.xml配置文件如下

 <!--通过工厂的形式来获取我们的用户对象-->
      <!--通过非静态的方法来创建我们的对象-->
      <!--创建我们的工厂对象-->
      <bean id="userFactory" class="com.qf.helloword.UserFactory"></bean>
      <!--调用方法获取我们的对象-->
      <bean id="nomalUser" factory-bean="userFactory" factory-method="getNormalInstancee"></bean>
       
       
       <!--通过工厂的形式调用静态的方法来获取JAVA对象-->
       <bean id="staticUser" class="com.qf.helloword.UserFactory" factory-method="getStaticInstance"></bean>

3>:测试方法跟HelloWorld一样如果能正常获取到对象那么恭喜你成功了....

               //第一步:获取我们的IOC容器
		ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
		//第二步:获取创建好的对象
		//User user=(User) context.getBean("staticUser");
		
		//获取对象的第二种模式 (如果采用了这种模式的话那么在IOC的容器中必须得保证只有User的一个实例存在)  
		User user=context.getBean("nomalUser");
		System.out.println(user+"------------");

4>:特殊类型对象的创建

<!--创建一个String类型的JAVA对象   new String()-->
        <bean id="dName" class="java.lang.String">
           <constructor-arg name="original" value="美女部"></constructor-arg>
        </bean>
        <bean id="dDes" class="java.lang.String">
           <constructor-arg name="original" value="这个部门负责安抚程序员"></constructor-arg>
        </bean>
        
        
        <!--创建一个int类型的变量-->
        <bean id="dId" class="java.lang.Integer">
           <constructor-arg index="0" value="130"></constructor-arg>
        </bean>

5>:创建具有构造函数的类的对象

<!--有参数的构造器的JAVA对象的生成-->
        <bean id="dept" class="com.qf.helloword.Dept">
           <!--给构造器传值  通过下标的形式来玩的  这种模式是有局限性的 index默认是从0开始的  后面的值必须和构造器中保持一致-->
           <constructor-arg index="0" value="110"></constructor-arg>
           <constructor-arg index="1" value="公关部"></constructor-arg>
           <constructor-arg index="2" value="负责公司整体形象的"></constructor-arg>
        </bean>
        <!--给构造器传值  通过名字的形式来进行玩的  前面是通过名字来玩的 顺序是可以颠倒的-->
        <bean id="dept1" class="com.qf.helloword.Dept">
           <constructor-arg name="dId" value="120"></constructor-arg>
           <constructor-arg name="dName" value="JAVAEE教学部"></constructor-arg>
           <constructor-arg name="dDes" value="搞教学的.."></constructor-arg>
        </bean>
        
        <!--给构造器传值  通过名字的形式来进行玩的   值的形式通过引用来玩的   ref是引用  那么这个ref引用的这个对象必须在IOC容器中存在  参考4-->
        <bean id="dept2" class="com.qf.helloword.Dept">
           <constructor-arg name="dId" ref="dId"></constructor-arg>
           <!--ref:表示的是引用 而且要使用ref的前提是 我们的IOC容器中必须要有这个JAVA对象存在-->
           <constructor-arg name="dName" ref="dName"></constructor-arg>
           <constructor-arg name="dDes" ref="dDes"></constructor-arg>
        </bean>

七:DI的几种方式

1>:Set注入(用的比较多)

xml配置:

      <!--创建DAO的实例-->
      <bean id="userDAO" class="com.qf.di.dao.UserDAO"></bean>
      
      <!--创建的是Service的实例-->
      <bean id="userService" class="com.qf.di.service.UserService">
         <!--主要你的JAVA对象中有set的属性那么这里的这个提示就一定有    ref:表示的是引用-->
         <property name="userDAO" ref="userDAO"></property>
      </bean>

      JAVA代码的编写

       public class UserService {

	private UserDAO userDAO=null;
	//Set注入的第一步:给维护的对象添加set方法
	public void setUserDAO(UserDAO userDAO) {
		this.userDAO = userDAO;
	}
     }

2>:p标签的形式进行注入

 注意:p标签注入首先得引入p标签的命名空间

          p标签注入也得有set方法

          p标签注入的案例:
           
           ref:表示引用的是一个对象(这个对象必须在IOC容器中存在)

          <bean id="userService1" class="com.qf.di.service.UserService" p:userDAO-ref="userDAO"></bean>

3>:内部bean进行注入

 <!--内部的bean进行注入  基本不会用-->
      <bean id="userService" class="com.qf.di.service.UserService">
          <property name="userDAO">
            <bean class="com.qf.di.dao.UserDAO">
               <property name="user">
                  <bean class="com.qf.helloword.User">
                     <constructor-arg name="uId" value="1"></constructor-arg>
                     <constructor-arg name="uName" value="小波波"></constructor-arg>
                     <constructor-arg name="uPwd" value="111"></constructor-arg>
                  </bean>
               </property>
            </bean>
          </property>
      </bean>

八:自动装配(减少配置的依然能实现自动注入)

 <!--自动装配
            autowire="byName" :这个表示的是通过名字进行自动装配
                         只要我们的bean使用了这个属性的话  就会找到名字和bean中属性名字 一致的这个bean对象进行赋值
            autowire="byType":叫做通过类型来进行自动的装配    只要在IOC容器中存在这种类型的对象那么就可以进行赋值了    -->

自动装配的使用例子如下

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName">
      
      <!--创建DAO的实例-->
     <!--  <bean id="userDAO" class="com.qf.di.dao.UserDAO"></bean> -->
      
      <!--创建的是Service的实例-->
    <!--   <bean id="userService" class="com.qf.di.service.UserService">
         主要你的JAVA对象中有set的属性那么这里的这个提示就一定有    ref:表示的是引用
         <property name="userDAO" ref="userDAO"></property>
      </bean> -->
      
      <!--玩下p标签注入-->
       <!-- <bean id="userService1" class="com.qf.di.service.UserService" p:userDAO-ref="userDAO"></bean> -->
      
      <!--内部的bean进行注入  基本不会用-->
      <!-- bean id="userService" class="com.qf.di.service.UserService">
          <property name="userDAO">
            <bean class="com.qf.di.dao.UserDAO">
               <property name="user">
                  <bean class="com.qf.helloword.User">
                     <constructor-arg name="uId" value="1"></constructor-arg>
                     <constructor-arg name="uName" value="小波波"></constructor-arg>
                     <constructor-arg name="uPwd" value="111"></constructor-arg>
                  </bean>
               </property>
            </bean>
          </property>
      </bean> -->
      
      <!--自动装配的玩法-->
      
      <bean id="user" class="com.qf.helloword.User"></bean>     
      <bean id="userService" class="com.qf.di.service.UserService"></bean>
      
      
      <!--自动装配
          autowire="byName" :这个表示的是通过名字进行自动装配
                         只要我们的bean使用了这个属性的话  就会找到名字和bean中属性名字 一致的这个bean对象进行赋值
           autowire="byType":叫做通过类型来进行自动的装配               
      -->
      <bean id="userDAO" class="com.qf.di.dao.UserDAO"></bean>
      
</beans>