一篇文章带你了解Java Spring基础与IOC
目录
- About Spring
- About IOC
- Hello Spring
- Hello.java
- Beans.xml
- Test.java
- IOC创建对象的几种方式
- Spring import settings
- Dependency Injection
- 1.构造器注入
- 2.set注入
- 3.拓展注入
- P-namespcae&C-namespace
- Bean scopes
- singleton
- prototype
- Bean的自动装配
- byName autowire
- byType autowire
- 小结
About Spring
开源免费框架,轻量级,非入侵式框架。Spring就是一个轻量级的控制反转(IOC)和面向切片编程(AOP)的框架
Maven repo:Spring Web MVC + spring-jdbc(整合Mybatis)
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.9</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.3.9</version> </dependency>
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; public Hello() { } public Hello(String str) { this.str = str; } public String getStr() { return str; } public void setStr(String str) { this.str = str; } @Override public String toString() { return "Hello{" + "str='" + str + '\'' + '}'; } }
Beans.xml
一个bean标签代表一个对象, id代表在Spring中这个类要实例化生成的对象的名字, class指定这个实体类
设置对象的属性值
引用Spring容器中创建的对象
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"> <!--使用Spring创建对象,Spring都称之为bean--> <!-- 一个bean标签代表一个对象, id代表要实例化的对象的名字, class指定这个实体类--> <bean id="hello" class="com.zh1z3ven.pojo.Hello"> <!-- 设置实体类的属性值--> <property name="str" value="Spring"/> </bean> </beans>
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容器中初始化了。
总体来说就两种方式:
无参构造
默认使用
有参构造
- 下标赋值
<!--通过下标赋值--> <bean id="hello2" class="com.zh1z3ven.pojo.Hello"> <constructor-arg index="0" value="Spring2"/> </bean>
- 类型复制
<!--通过类型赋值--> <bean id="hello3" class="com.zh1z3ven.pojo.Hello"> <constructor-arg type="java.lang.String" value="Spring3"/> </bean>
- 属性名赋值
<!--属性名赋值--> <bean id="hello4" class="com.zh1z3ven.pojo.Hello"> <constructor-arg name="str" value="Spring4"/> </bean>
Spring import settings
import标签可导入其他beans.xml配置文件,而applicationContext.xml到时可作为总bean的配置文件,而不需要导入多个xml
Dependency Injection
依赖注入(Dependency Injection,DI)
PS:一定需要pojo中实现set才可以利用bean标签注入
1.构造器注入
也就是上面提到的创建对象的方式,分为无参构造和有参构造
无参构造
默认使用
有参构造
- 下标赋值
<!--通过下标赋值--> <bean id="hello2" class="com.zh1z3ven.pojo.Hello"> <constructor-arg index="0" value="Spring2"/> </bean>
- 类型复制
<!--通过类型赋值--> <bean id="hello3" class="com.zh1z3ven.pojo.Hello"> <constructor-arg type="java.lang.String" value="Spring3"/> </bean>
- 属性名赋值
<!--属性名赋值--> <bean id="hello4" class="com.zh1z3ven.pojo.Hello"> <constructor-arg name="str" value="Spring4"/> </bean>
2.set注入
依赖:bean对象的注入依赖于Spring容器
注入:bean对象的属性,由容器来注入
3.拓展注入
Student.java
public class Student { private String name; private Address address; private String[] books; private List<String> hobbys; private Map<String,String> card; private Set<String> 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<String> getHobbys() { return hobbys; } public void setHobbys(List<String> hobbys) { this.hobbys = hobbys; } public Map<String, String> getCard() { return card; } public void setCard(Map<String, String> card) { this.card = card; } public Set<String> getGames() { return games; } public void setGames(Set<String> 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
<bean id="address" class="com.zh1z3ven.pojo.Address"> <property name="address" value="beijing"/> </bean> <bean id="student1" class="com.zh1z3ven.pojo.Student"> <!-- 普通属性值注入--> <property name="name" value="zh1z3ven"/> <!-- ref 引用对象注入--> <property name="address" ref="address"/> <!-- 数组array注入--> <property name="books"> <array> <value>红楼梦</value> <value>西游记</value> <value>水浒传</value> <value>三国演义</value> </array> </property> <!-- List注入--> <property name="hobbys"> <list> <value>听音乐</value> <value>看电影</value> <value>敲代码</value> <value>写文章</value> </list> </property> <!-- Map注入--> <property name="card"> <map> <entry key="银行卡" value="1"></entry> <entry key="身份证" value="2"></entry> <entry key="学生证" value="3"></entry> <entry key="电话卡" value="4"></entry> <entry key="校园卡" value="5"></entry> </map> </property> <!-- Set注入--> <property name="games"> <set> <value>LOL</value> <value>CF</value> <value>qq</value> </set> </property> <!-- null注入--> <property name="wife"> <null></null> </property> <!-- 空值注入--> <property name="apache" value=""/> <!-- properties--> <property name="info"> <props> <prop key="id">10</prop> <prop key="city">北京</prop> </props> </property> </bean>
P-namespcae&C-namespace
1.p命名空间注入,可以直接注入属性值,类似于bean标签中property-name-value
Beans.xml头部需导入
xmlns:p="http://www.springframework.org/schema/p"
<bean id="user1" class="com.zh1z3ven.pojo.User" p:name="zh1z3ven1" p:age="18"/>
2.c命名空间注入,通过构造器注入,类似于construct-args(需要实现有参构造)
xmlns:c="http://www.springframework.org/schema/c"
<bean id="user2" class="com.zh1z3ven.pojo.User" c:name="zh1z3ven2" p:age="19"/>
@Test public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); User user1 = context.getBean("user1", User.class); 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单例模式运行的
显示定义:<bean id="user1" class="com.zh1z3ven.pojo.User" p:name="zh1z3ven1" p:age="18" scope="singleton"/>
单例模式,共享一个对象,比如如下例子,getBean指向的是同一个bean,那么在Spring IoC容器中仅仅会生成一个"user2"对象保存在内存中,当调用ApplicationContext.getBean(“user2”)时返回该对象
<bean id="user2" class="com.zh1z3ven.pojo.User" c:name="zh1z3ven2" c:age="19"/>
@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(需要在上下文中所有类型各自只出现一次)
<bean id="people" class="com.zh1z3ven.pojo.People" autowire="byType"> <property name="name" value="zh1z3ven"/> </bean>
小结
- byname需要保证所有bean的id唯一,且这个bean的id的值要和需要自动装配依赖注入的set方法的值一致。
- bytype需要保证所有bean的class唯一,且这个bean的class的值需要和set方法的值的类型一致。
注解实现自动装配
xml配置
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> </beans>
@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 resource="beans.xml"/>
使用方法
@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的资料请关注我们其它相关文章!