spring介绍与ioc控制反转(一)【SSM框架】

一.spring介绍

spring全家桶:spring , springmvc ,spring boot , spring cloud

spring: 出现是在2002左右,解决企业开发的难度。减轻对项目模块之间的管理,
类和类之间的管理, 帮助开发人员创建对象,管理对象之间的关系。
spring核心技术 ioc , aop 。能实现模块之间,类之间的解耦合。

依赖:classa中使用classb的属性或者方法, 叫做classa依赖classb


2.框架怎么学
1)知道框架能做什么, mybatis–访问数据库, 对表中的数据执行增删改查。
2)框架的语法, 框架要完成一个功能,需要一定的步骤支持的,
3)框架的内部实现, 框架内部怎么做。 原理是什么。
4)通过学习,可以实现一个框架。

二.spring的第一个核心功能 ioc

IoC (Inversion of Control) : 控制反转, 是一个理论,概念,思想。
描述的:把对象的创建,赋值,管理工作都交给代码之外的容器实现, 也就是对象的创建是有其它外部资源完成。

控制: 创建对象,对象的属性赋值,对象之间的关系管理。
反转: 把原来的开发人员管理,创建对象的权限转移给代码之外的容器实现。 由容器代替开发人员管理对象。创建对象,给属性赋值。

正转:由开发人员在代码中,使用new 构造方法创建对象, 开发人员主动管理对象。
public static void main(String args[]){
Student student = new Student(); // 在代码中, 创建对象。–正转。
}

容器:是一个服务器软件, 一个框架(spring)

为什么要使用 ioc : 目的就是减少对代码的改动, 也能实现不同的功能。 实现解耦合。

2.1 java中创建对象有哪些方式:

  • 构造方法 , new Student()
  • 反射
  • 序列化
  • 克隆
  • ioc :容器创建对象
  • 动态代理

2.2 ioc的体现:

servlet

  1. 创建类继承HttpServelt
  2. 在web.xml 注册servlet , 使用
<servlet-name> myservlet servlet-name>
<servelt-class>com.tx.controller.MyServlet1servlet-class>
  1. 没有创建 Servlet对象, 没有 MyServlet myservlet = new MyServlet()
  2. Servlet 是Tomcat服务器它能你创建的。 Tomcat也称为容器
    Tomcat作为容器:里面存放的有Servlet对象, Listener , Filter对象

2.3.IoC的技术实现 ,

2.3.1 DI 是ioc的技术实现

DI(Dependency Injection) :依赖注入, 只需要在程序中提供要使用的对象名称就可以, 至于对象如何在容器中创建,赋值,查找都由容器内部实现。

spring是使用的di实现了ioc的功能, spring底层创建对象,使用的是反射机制。
spring是一个容器,管理对象,给属性赋值, 底层是反射创建对象。

Spring 容器是一个超级大工厂,负责创建、管理所有的 Java 对象,这些 Java 对象被称
为 Bean。Spring 容器管理着容器中 Bean 之间的依赖关系,Spring 使用“依赖注入”的方式
来管理 Bean 之间的依赖关系。使用 IoC 实现对象之间的解耦和。

resources.bean.xml文件
   
    <bean id="someService" class="com.tx.service.impl.SomeServiceimpl">bean>

    <bean id="someService1" class="com.tx.service.impl.SomeServiceimpl" scope="prototype" >bean>

    
    <bean id="mydate" class="java.util.Date">bean>
beans>


   /**
     * spring默认创建对象的时间:在创建spring的容器时,会创建配置文件中的所有对象
     * spring创建对象:默认调用的是无参构造方法
     * */
   public void test02(){
     
        //使用spring容器创建的对象
        //1.指定spring配置文件的名称
        String config = "beans.xml";
        //2.创建表示spring容器的对象,ApplicationContext
        //ApplicationContext就是表示spring容器,通过容器获取对象了
        //ClassPathXmlApplicationContext:表示从类路径中加载spring的配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        //从容器中获取某个对象,你要调用对象的方法
        //getBean("配置文件中的bean的id值")
        SomeService service = (SomeService) ac.getBean("someService");
        //使用spring创建对象
        service.doSome();

		//使用spring提供的方法,获取容器中定义的对象数量
		int nums = ac.getBeanDefinitionCount();
		System.out.println("容器中有多少个对象:"+nums);//容器中有多少个对象:1
    }

2.3.2 基于xml的DI

2.1注入分类

1.set注入(设值注入) :spring调用类的set方法, 你可以在set方法中完成属性赋值

  1. 简单类型的set注入
<bean id="xx" class="yyy">
   <property name="属性名字" value="此属性的值"/>
   一个property只能给一个属性赋值
   <property....>
bean>
  1. 引用类型的set注入 : spring调用类的set方法
<bean id="xxx" class="yyy">
	<property name="属性名称" ref="bean的id(对象的名称)" />
bean>
<bean id="myStudent" class="com.tx.ba02.Student" >
    <property name="name" value="李四" />
    <property name="age" value="26" />
    
    <property name="school" ref="mySchool" />
bean>

2.构造注入(理解)

<bean id="myStudent" class="com.tx.ba02.Student" >
  <constructor-arg name="myage" value="22"/>
  <constructor-arg name="myname" value="李四"/>
  <constructor-arg name="myXueXiao" ref="mySchool"/>
bean>

2.2引用类型属性自动注入

1.byName(按名称注入) : java类中引用类型的属性名和spring容器中(配置文件)< bean>的id名称一样,
------------------------------------且数据类型是一致的,这样的容器中的bean,spring能够赋值给引用类型。
语法:

 
    <bean id="myStudent" class="com.tx.ba04.Student"  autowire="byName">
        <property name="name" value="李四" />
        <property name="age" value="26" />
        
        
    bean>
    
    <bean id="school" class="com.tx.ba04.School">
        <property name="name" value="清华大学"/>
        <property name="address" value="北京的海淀区" />
    bean>

2.byType(按类型注入) : java类中引用类型的数据类型和spring容器中(配置文件< bean>的class属性
----------------------------------是同源关系的,这样的bean能够赋值给引用类型
同源就是一类的意思:

  1. java类中引用类型的数据类型和bean的class的值是一样的。
  2. java类中引用类型的数据类型和bean的class的值父子类关系的。
  3. java类中引用类型的数据类型和bean的class的值接口和实现类关系的
    语法:

<bean id="myStudent" class="com.tx.ba05.Student"  autowire="byType">
    <property name="name" value="张飒" />
    <property name="age" value="26" />
    
    
bean>


<bean id="mySchool" class="com.tx.ba05.School">
    <property name="name" value="人民大学"/>
    <property name="address" value="北京的海淀区" />
bean>

2.3 为应用指定多个 Spring 配置文件

ba06/spring-total.xml
   

    
    

    
    <import resource="classpath:ba06/spring-*.xml" />
beans>
public void test01(){
     
	//加载的是总的文件
	String config = "ba06/spring-total.xml";
	ApplicationContext ac = new ClassPathXmlApplicationContext(config);
	//从容器中获取Student对象
	Student myStudent = (Student) ac.getBean("myStudent");
	System.out.println("student对象="+myStudent);
}

2.3.3 基于注解的 DI

使用注解的步骤:
1.加入maven的依赖 spring-context ,在你加入spring-context的同时, 间接加入spring-aop的依赖。使用注解必须使用spring-aop依赖


<dependency>
  <groupId>org.springframeworkgroupId>
  <artifactId>spring-contextartifactId>
  <version>5.2.5.RELEASEversion>
dependency>

2.在类中加入spring的注解(多个不同功能的注解)

/**
 * @Component: 创建对象的, 等同于的功能
 *     属性:value 就是对象的名称,也就是bean的id值,
 *          value的值是唯一的,创建的对象在整个spring容器中就一个
 *     位置:在类的上面
 *
 *  @Component(value = "myStudent")等同于
 *   
 *
 *  spring中和@Component功能一致,创建对象的注解还有:
 *  1.@Repository(用在持久层类的上面) : 放在dao的实现类上面,
 *               表示创建dao对象,dao对象是能访问数据库的。
 *  2.@Service(用在业务层类的上面):放在service的实现类上面,
 *              创建service对象,service对象是做业务处理,可以有事务等功能的。
 *  3.@Controller(用在控制器的上面):放在控制器(处理器)类的上面,创建控制器对象的,
 *              控制器对象,能够接受用户提交的参数,显示请求的处理结果。
 *  以上三个注解的使用语法和@Component一样的。 都能创建对象,但是这三个注解还有额外的功能。
 *  @Repository,@Service,@Controller是给项目的对象分层的。
 *
 */
//使用value属性,指定对象名称
//@Component(value = "myStudent")
//省略value
@Component("myStudent")
//不指定对象名称,由spring提供默认名称: 类名的首字母小写,这里也就是:student;
//@Component
public class Student {
     }

3.在spring的配置文件中,加入一个组件扫描器的标签,说明注解在你的项目中的位置

  
   
    
    <context:component-scan base-package="com.tx.ba01"/>
    <context:component-scan base-package="com.tx.ba02"/>

    
    <context:component-scan base-package="com.tx.ba01;com.tx.ba02" />

    
    <context:component-scan base-package="com.tx" />
  • 学习的注解:
    1.@Component
    2.@Respotory
    3.@Service
    4.@Controller
    5.@Value
     /**
     * @Value: 简单类型的属性赋值
     *   属性: value 是String类型的,表示简单类型的属性值
     *   位置: 1.在属性定义的上面,无需set方法,推荐使用。
     *         2.在set方法的上面
     */
    @Value("李四" )
    private String name;
    private Integer age;
    
    /**
     * 引用类型
     * @Autowired: spring框架提供的注解,实现引用类型的赋值。
     * spring中通过注解给引用类型赋值,使用的是自动注入原理 ,支持byName, byType
     * @Autowired:默认使用的是byType自动注入。
     *
     * 属性:required ,是一个boolean类型的,默认true
     *       required=true:表示引用类型赋值失败,程序报错,并终止执行。
     *       required=false:引用类型如果赋值失败, 程序正常执行,引用类型是null
     * 
     *  位置:1)在属性定义的上面,无需set方法, 推荐使用
     *       2)在set方法的上面
     *  如果要使用byName方式,需要做的是:
     *  1.在属性上面加入@Autowired
     *  2.在属性上面加入@Qualifier(value="bean的id") :表示使用指定名称的bean完成赋值。
     */
    //默认byType自动注入
    @Autowired
    private School school;
    //byName自动注入
    @Autowired
    @Qualifier("mySchool")
    private School school;	
    
    6.@Autowired
    7.@Resource
    /**
     * 引用类型
     * @Resource: 来自jdk中的注解,spring框架提供了对这个注解的功能支持,可以使用它给引用类型赋值
     *            使用的也是自动注入原理,支持byName, byType .默认是byName
     *  位置: 1.在属性定义的上面,无需set方法,推荐使用。
     *        2.在set方法的上面
     * @Resource只使用byName方式,需要增加一个属性 name
     * name的值是bean的id(名称)
     */
    //默认是byName: 先使用byName自动注入,如果byName赋值失败,再使用byType
    @Resource
    private School school;
    

@Value搭配配置文件

 
    <context:property-placeholder location="classpath:test.properties" />
@Value("${myage}")
private String name;

用户处理请求:
用户form ,参数name ,age-----Servlet(接收请求name,age)—Service类(处理name,age操作)—dao类(访问数据库的)—mysql

你可能感兴趣的:(笔记,spring,java)