栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring 学习(一)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring 学习(一)

Spring框架

它是一个容器,它是整合其它框架的框架,它的核心是IOC和AOP,它由20多个模块构成,它在很多领域都提供优秀的解决方法。

主要作用

是降低代码间的耦合度,使用IOC降低业务对象之间耦合度,AOP使得系统级服务得到了最大复用。

轻量级:由20多个模块构造,每个jar包都很小,小于1M,核心包也就3M,对代码无污染

面向接口编程:就是面向灵活,项目的可扩展性,可维护性都极高,接口不关心实现类的类型,使用接口指向实现类,切换实现类即可切换整个功能

AOP:面向切面编程,将公共的,通用的,重复的代码单独开发,在需要的时候反织回去,底层的原理是动态代理

整合其它框架:它整合后使得其它框架易用

IOC控制反转

控制反转IOC(Inversion of Control) 是一个概念,是一种思想,由spring容器进行对象的创建和依赖注入,程序员在使用时直接取出使用

正转:由程序员进行对象的创建和依赖注入(不好)

Student stu=new Student();//程序员创建对象

stu.setName("张三");//程序员依赖注入

stu.setAge(22);

反转:由spring容器创建对象和依赖注入,将控制权从程序员手中夺走。

//spring容器创建对象
  
    //spring容器依赖注入

 

创建项目

新建项目添加模块maven,选择从原形创建

 创建好后在main文件下添加resources 文件夹

 然后在pom.xml中添加spring依赖


      
          org.springframework
          spring-context
          5.2.5.RELEASE
      

 依赖添加好后在resources中创建配置文件

 基于xml的IOC

1.创建对象




    

    






//spring配置文件内容

实体类对象

package ys.com;

public class Student {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

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

    public Student(){
        System.out.println("学生的无参的构造方法。。。");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}
给创建的对象赋值

1.使用setter注入(必须提供无参的构造方法,必须提供setXXX()方法)

简单类型注入:注入值使用value


        
        
    

引用类型注入:注入值使用ref---ref的值为其他bean 的id值

再创建一个新的实体类(school),并在student类中加入school类型的变量

 private School school;


    public void setSchool(School school) {
        this.school = school;
    }

在spring配置文件中添加代码

  
        
        

    
    
        
        
        
    

2.使用构造方法注入

Studnet student = new Student ("张三",20);

使用构造方法的参数名称进行注入值

使用构造方法的参数的下标进行注入值

使用默认的构造方法的参数的顺序注入值

创建一个实体类,添加有参的构造函数

package ys.com;

public class School {
    private  String name;
    private  String address;

    
    @Override
    public String toString() {
        return "School{" +
                "name='" + name + ''' +
                ", address='" + address + ''' +
                '}';
    }

    public School(String name, String address) {
        this.name = name;
        this.address = address;
    }
   
}

在spring配置文件中添加---name为实际参数名,不是方法中定义的名字


        
        
    
//使用构造方法的参数名称进行注入值

 
        
        
        
    

//使用构造方法的参数的下标进行注入值


        
        
        
    

//使用默认的构造方法的参数的顺序注入值---顺序不能更改

在主方法中输出

public class main {
    public static void main(String[] args) {
        //创建容器对象,并启动才可以取对象
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        //取出对象,stu为spring配置文件中对应的id值
        School school =(School) applicationContext.getBean("school1");
        System.out.println(school);
    }
}



//想输出那个对象  就把getBean中的值改成对应的在spring配置文件中的id
//要记得对象的改变 
基于注解的IOC的基本概念--(注解离不开包扫描)

也称为DI(Dependency Injection),它是IOC的具体实现技术

创建对象并依赖注入      注解annotation

1.创建对象的注解

@Component:可以创建任意对象,创建的对象默认名称为类名的驼峰命名法,也可以指定@Component("自定义名称")

@Controller:专门用来创建控制器的对象(Servlet),这种对象可以接收用户的请求,可以返回处理结果给客户端

@Service:专门用来创建业务逻辑层的对象,负责向下访问数据访问层,处理完毕后的结果返回给界面层

@Repository:专门用来创建数据访问层的对象,负责数据库中的增删改查所以操作

2.依赖注入的注解

值类型的注入(@Value):用来给简单类型注入值

引用类型的注入

@Autowired:使用类型注入值,从整个Bean工厂中搜索同源类型的对象进行注入

同源类型也可以注入

同源类型:被注入的类型与注入的类型是完全相同的类型,被注入的类型(父类)与注入的类型(子类)是父子类,被注入的类型(接口)与注入的类型(实现类)是接口和实现类。

@Autowired(俩个共同使用)

@Qualifier:使用名称注入值,从整个Bean工厂中搜索相同名称的对象进行注入

3.包扫描的几种方式

单个包扫描(推荐使用)








 多个包扫描----多个包直接以逗号或空格或分号分隔

扫描根包(不推荐)----相当于全局扫描,会降低Spring的启动速度,会导致多扫许多没有注解的类

package com.ys;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component //交给Spring去创建对象,就是在容器启动时创建
public class Student {
    @Value("张三")//使用注解注入值
    private String name;
    @Value("22")
    private int age;
//    引用类型按名称注入
    @Autowired
    @Qualifier("school")
    private School school;
//@Autowired    引用类型按类型注入
//private School school;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }

    public Student(){
        System.out.println("无参函数被调用");
    }
}
package com.ys;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.SplittableRandom;
@Component
public class School {
    @Value("清华大学")
    private String name;
    @Value("海淀区")
    private String address;

    public School() {
        System.out.println("school的无参构造方法");
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + ''' +
                ", address='" + address + ''' +
                '}';
    }
}
package com.ys.main;

import com.ys.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class myapp {
    public static void main(String[] args) {
        ApplicationContext ac=new ClassPathXmlApplicationContext("Springcon.xml");
        Student stu =(Student) ac.getBean("student");//student为Spring自动生成的名称,为对应类的驼峰命名法的命名
        System.out.println(stu);
    }
};


       //包扫描,只有经过了包扫描的类才能被识别注解

在有父子类的情况下,使用按类型注入,就意味着有多个对象可以注入,此时按照名称进行二次筛选,选中与被注入对象相同名称的对象进行注入

即被注入的类中的对象类型,与父子类中类的@Component生成或自定义的名相同就注入哪个的值,推荐使用名称注入,直接使用名称进行选择注入类。

 基于上面的代码 再创建一个java类 作为School的子类如下:

package com.ys.main;

import com.ys.School;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class SonSchool extends School {
    @Value("清华附小")
    private String name;
    @Value("海淀小区")
    private String adderss;

    public SonSchool() {
        System.out.println("子类的构造函数被调用");
    }

    @Override
    public String toString() {
        return "SonSchool{" +
                "name='" + name + ''' +
                ", adderss='" + adderss + ''' +
                '}';
    }
}

运行程序结果如下

 从结果可以看见school被调用两次,则有创建子类对象,默认调用父类的无参构造方法

修改School和SonSchool的名称

@Component("schoolNew")

public class School {

}


@Component("school")

public class SonSchool extends School {

}

结果如下:

为应用指定多个Spring配置文件----拆分Spring配置文件

当项目越来越大,需要多人合作开发,一个配置文件被多人不断修改,会导致许多麻烦。

拆分策略

按层拆:按照项目的层次结构(三层结构)拆分,每一层结构都有一个Spring配置文件

按功能拆:按照项目的功能拆分,一个或多个功能配置一个Spring配置文件

xml的引用类型的自动注入

autowire 自动注入  byName 按名字自动注入   byType 按类型自动注入

 

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/952653.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号