一篇文章带你了解Java Spring基础与IOC

一篇文章带你了解Java Spring基础与IOC

目录About SpringAbout IOCHello SpringHello.javaBeans.xmlTest.javaIOC创建对象的几种方式Spring import settingsDependency Injection1.构造器注入2.set注入3.拓展注入P-namespcae&C-namespaceBean scopessingletonprototypeBean的自动装配byName autowirebyType autowire小结

About Spring

开源免费框架，轻量级，非入侵式框架。Spring就是一个轻量级的控制反转（IOC）和面向切片编程（AOP）的框架

Maven repo：Spring Web MVC + spring-jdbc(整合Mybatis)

org.springframework

spring-webmvc

5.3.9

org.springframework

spring-jdbc

5.3.9

Spring两大特点

控制反转（IOC）

面向切片编程（AOP）支持事务处理

About IOC

控制反转：IOC是一种设计思想，通过描述（XML或注解）并通过第三方生产或获取对象的方式。之前对象的创建与对象的依赖关系完全在java硬编码程序中，控制权在程序；实现IOC后，控制权在第三方，实现降藕。

在Spring中实现控制反转的是 IoC容器 ，实现方法是 依赖注入DI（Dependency Injection,DI）

引用狂神的一个例子简单理解下

private UserDao userDao = null;

public UserServiceImpl(){

userDao = new UserDaoImpl();

}

在之前我们使用JavaWeb写service=>dao的时候，是通过如上的方式去实现的，项目构建大概如下

那么如果此时我的UserDao接口又了一个新的实现类暂且为 UserDaoImpls ，这个实现类中有新的功能实现，那么就需要到UserServiceImpl中再去构造方法加一段如下的代码：

userDao = new UserDaoImpls();

那么这时如果该项目还没发布那到无所谓，如果是已经上线的项目是不可能这样重新去修改代码的，或者如果有n个new，就要修改n处。

解决这个问题就是通过一个set方法。如下：

public void setUserDao(UserDao userDao) {

this.userDao = userDao;

}

在构造方法中实例化对象的这个操作，改为利用set封装并将需要new的实现类的名称变为set方法的参数，实现用户可控的去new一个新的实现类从而添加新的功能展示到页面。

而这个思想就是控制反转（IOC）的原型，将new实现类对象的主动权交给了用户而不是程序，从本质上解决了上面的问题，也实现了降藕。

Hello Spring

Hello.java

package com.zh1z3ven.pojo;

public class Hello {

private String str;

publichttp:// Hello() {

}

public Hello(String str) {

this.str = str;

}

public String getStr() {

return str;

}

public void setStr(String str) {

this.str = str;

}

@Override

public String toStringhttp://() {

return "Hello{" +

"str='" + str + '\'' +

'}';

}

}

Beans.xml

一个bean标签代表一个对象， id代表在Spring中这个类要实例化生成的对象的名字， class指定这个实体类

设置对象的属性值

引用Spring容器中创建的对象

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

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

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

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

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

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

Test.java

在Spring中也存在一个上下文，通过 ApplicationContext context = new ClassPathXmlApplicationContext(“beans.xml”); 传入xml配置文件名字来获取该xml文件的上下文对象。利用 ApplicationContext#getBean() 传入在xml中配置的该类的id获取该实体类对象。

public class MyTest {

public static void main(String[] args) {

//获取Spring上下文对象

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

//从Spring中取出对象

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

System.out.println(hello);

}

}

IOC创建对象的几种方式

PS:在配置文件加载的时候，通过bean标签注册的对象就已经在Spring IoC容器中初始化了。

总体来说就两种方式：

无参构造

默认使用

有参构造

下标赋值

类型复制

属性名赋值

Spring import settings

import标签可导入其他beans.xml配置文件，而applicationContext.xml到时可作为总bean的配置文件，而不需要导入多个xml

Dependency Injection

依赖注入（Dependency Injection，DI）

PS：一定需要pojo中实现set才可以利用bean标签注入

1.构造器注入

也就是上面提到的创建对象的方式，分为无参构造和有参构造

无参构造

默认使用

有参构造

下标赋值

类型复制

属性名赋值

2.set注入

依赖：bean对象的注入依赖于Spring容器

注入：bean对象的属性，由容器来注入

3.拓展注入

Student.java

public class Student {

private String name;

private Address address;

private String[] books;

private List hobbys;

private Map card;

private Set games;

private String wife;

private String apache;

private Properties info;

public String getApache() {

return apache;

}

public void setApache(String apache) {

this.apache = apache;

}

public String[] getBooks() {

return books;

}

public void setBooks(String[] books) {

this.books = books;

}

public List getHobbys() {

return hobbys;

}

public void setHobbys(List hobbys) {

this.hobbys = hobbys;

}

public Map getCard() {

return card;

}

public void setCard(Map card) {

this.card = card;

}

public Set getGames() {

return games;

}

public void setGames(Set games) {

this.games = games;

}

public String getWife() {

return wife;

}

public void setWife(String wife) {

this.wife = wife;

}

public Properties getInfo() {

return info;

}

public void setInfo(Properties info) {

this.info = info;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Address getAddress() {

return address;

}

public void setAddress(Address address) {

this.address = address;

}

@Override

public String toString() {

return "Student{" +

"name='" + name + '\'' +

", address=" + address +

", books=" + Arrays.toString(books) +

", hobbys=" + hobbys +

", card=" + card +

", games=" + games +

", wife='" + wife + '\'' +

", info=" + info +

'}';

}

}

beans.xml

红楼梦

西游记

水浒传

三国演义

听音乐

看电影

敲代码

写文章

LOL

CF

qq

10

北京

P-namespcae&C-namespace

1.p命名空间注入，可以直接注入属性值，类似于bean标签中property-name-value

Beans.xml头部需导入

xmlns:p="http://springframework.org/schema/p"

2.c命名空间注入，通过构造器注入，类似于construct-args(需要实现有参构造)

xmlns:c="http://springframework.org/schema/c"

@Test

public void test(){

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

User user1 = context.getBean("user1", User.clhttp://ass);

System.out.println(user1.getName());

System.out.println(user1.getAge());

User user2 = context.getBean("user2", User.class);

System.out.println(user2.getName());

System.out.println(user2.getAge());

}

Bean scopes

bean的作用域

singleton

默认bean为scope = singleton单例模式运行的

显示定义：

单例模式，共享一个对象,比如如下例子,getBean指向的是同一个bean，那么在Spring IoC容器中仅仅会生成一个"user2"对象保存在内存中，当调用ApplicationContext.getBean(“user2”)时返回该对象

@Test

public void test(){

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

User user1 = context.getBean("user2", User.class);

User user2 = context.getBean("user2", User.class);

System.out.println(user1==user2);

}

prototype

原型模式prototype与singleton不同，每次上下文去getBean()时都会在Spring IoC容器内创建一次该对象

还是拿上面的测试代码，可以发现已经不是同一个对象了，有点类似于多态

public void test2(){

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

User user1 = context.getBean("user2", User.class);

User user2 = context.getBean("user2", User.class);

System.out.println(user1==user2);

}

而其余的生命周期在Web中才会遇到。

Bean的自动装配

在xml显示配置bean

在java代码中配置bean

隐式自动装配bean【autowire】

byName autowire

会在容器上下文中自动查找，和自己对象set方法后面的值对应的beanid。也就是这里会去上下文中寻找有无"cat"这个beanid，有则自动装配，如果并没有匹配上，比如此时beanid被修改为了"cat123" 就会跑出异常。

byType autowire

会在容器上下文中寻找该类型与属性值所对应的类型相同的bean，基于bean中的class（需要在上下文中所有类型各自只出现一次）

小结

byname需要保证所有bean的id唯一，且这个bean的id的值要和需要自动装配依赖注入的set方法的值一致。

bytype需要保证所有bean的class唯一，且这个bean的class的值需要和set方法的值的类型一致。

注解实现自动装配

xml配置

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

xmlns:context="http://springframework.org/schema/context"

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

https://springframework.org/schema/beans/spring-beans.xsd

http://springframework.org/schema/context

https://springframework.org/schema/context/spring-context.xsd">

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

xmlns:context="http://springframework.org/schema/context"

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

https://springframework.org/schema/beans/spring-beans.xsd

http://springframework.org/schema/context

https://springframework.org/schema/context/spring-context.xsd">

@Autowired

默认使用byname方式去自动装配，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。

在使用@Autowired时，首先在容器中查询对应类型的bean（bytype）

如果查询结果刚好为一个，就将该bean装配给@Autowired指定的数据

如果查询的结果不止一个，那么@Autowired会根据名称来查找。（byname）

如果查询的结果为空，那么会抛出异常。解决方法时，使用@Autowried(required=false)

public class People {

@Autowired

private Cat cat;

@Autowired

private Dog dog;

private String name;

@Qualifier

如果存在多个类型且该类型有多个不同名字的对象，那么只用@Autowired会找不到该对象，可以配合@Qualifier(value="")来指定一个装配的值。

@Autowired

@Qualifier(value="dog222")

@Resource

java自带的一个注解，和@Autowired，@Qualifier组合用法和效果基本是一样

javax.annotation.Resource

@Resource //不指定名称自动装配

@Resource(name="") //指定名称自动装配

使用注解开发

bean在xml里注册，属性值通过注解注入

@component

泛指各种组件，把普通pojo实例化到spring容器中,相当于配置文件中的bean,将该类在配置文件下注册到Spring容器中装配bean。类似的还有：

1、@controller 控制器（注入服务） 用于标注控制层，相当于struts中的action层

2、@service 服务（注入dao） 用于标注服务层，主要用来进行业务的逻辑处理

3、@repository（实现dao访问） 用于标注数据访问层，也可以说用于标注数据访问组件，即DAO组件

##@Scope

生命周期,用法：在目标类上面声明

@Scope("singleton")

@Configuration

用于声明这是一个配置类

@Bean

相当于在配置文件中注册bean

方法名为之前的id属性

方法返回值为之前的class属性

@Import

导入其他配置类，等价于

使用方法

@Import(Config.class)

示例代码

pojo

//相当于在bean中注册,相当于在Spring IoC容器new一个对象

@Component

public class User {

@Value("CoLoo")

public String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public String toString() {

return "User{" +

"name='" + name + '\'' +

'}';

}

}

config

@Configuration

@ComponentScan("com.zh1z3ven.pojo")

public class AppConfig {

@Bean

public User getUser(){

return new User();

}

}

test

public class MyTest {

public static void main(String[] args) {

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

User user = context.getBean("user", User.class);

System.out.println(user.getName());

}

}

以上就是一篇文章带你了解Java Spring基础与IOC的详细内容，更多关于Java Spring与IOC的资料请关注我们其它相关文章！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。