狂神说Java-Spring详解
1、Spring
1.1、简介
Spring：春天----->给软件⾏业带来了春天!
2002，⾸次推出了Spring框架的雏形: interface21框架!
Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3⽉24⽇，发布了1.0正式版。
Rod Johnson ,Spring Framework创始⼈，著名作者。很难想象Rod Johnson的学历，真的让好多⼈⼤吃⼀惊，他是悉尼⼤学的博⼠，然⽽他的专业不是计算机，⽽是⾳乐学。
spring理念：使现有的技术更加容易使⽤，本⾝是⼀个⼤杂烩，整合了现有的技术框架!
SSH : Struct2 + Spring + Hibernate !
SSM : SpringMvc + Spring + Mybatis!
官⽹: https:/lspring.io/projects/spring-framework#overview
GitHub: https:/lgithublspring-projects/spring-framework
1 <!-- https : //mvnrepository/artifact/org.springframework/spring-webmvc -->2<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</ artifactId>
<version>5.2.O.RELEASE</version>
</ dependency>
<!-- mvnrepository/artifact/org.springframework/spring-webmvc -->8<dependency>
<groupId>org.springframework</groupId>
<artifactid>spring-jdbc</artifactId>
<cversion>5.2.0.RELEASE</version>
</ dependency>
1.2、优点
Spring是⼀个开源的免费的框架（容器)!
Spring是⼀个轻量级的、⾮⼊侵式的框架!
控制反转(IOC)，⾯向切⾯编程(AOP) !
⽀持事务的处理，对框架整合的⽀持!
总结⼀句话: Spring就是⼀个轻量级的控制反转（IOC)）和⾯向切⾯编程（AOP）的框架!
2、IOC理论推导
1. UserDao 接⼝
2. UserDaoImpl 接⼝实现类
3. UserService 业务接⼝
4. UserServiceImpl 业务实现类
在之前的业务中，⽤户的需求可能会影响我们原来的代码，我们需要根据⽤户的需求去修改源代码，如果程序代码量⼗分⼤，修改⼀次的成本代价⼗分昂贵！
我们使⽤⼀个Set接⼝实现，已经发⽣了⾰命性的变化！
//利⽤set动态实现值的注⼊
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
之前，程序是主动创建对象，控制权在程序员⼿上！
使⽤了Set注⼊后，程序不再具有主动性，⼆⼗变成了被动的接受对象
这种思想，从本质上解决了问题，我们程序员不⽤再去管理对象的创建！系统的耦合性⼤⼤降低，可以更加专注在业务的实现上！这是IOC 的原型！
IOC本质
控制反转loC(Inversion of Control)，是⼀种设计思想，DI(依赖注⼊)是实现loC的⼀种⽅法，也有⼈认为DI只是loC的另⼀种说法。没有loC的程序中，我们使⽤⾯向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序⾃⼰控制，控制反转后将对象的创建转移给第三⽅，个⼈认为所谓控制反转就是︰获得依赖对象的⽅式反转了。
采⽤XML⽅式配置Bean的时候，Bean的定义信息是和实现分离的，⽽采⽤注解的⽅式可以把两者合为⼀体，Bean的定义信息直接以注解的形式定义在实现类中，从⽽达到了零配置的⽬的。
控制反转是⼀种通过描述（XML或注解）并通过第三⽅去⽣产或获取特定对象的⽅式。在Spring中实现控制反转的是loC容器，其实现⽅法是依赖注⼊(Dependency Injection,Dl)。
3、IOC创建对象的⽅式
1.使⽤⽆参构造创建对象，默认！
2.假设我们要使⽤有参构造创建对象
1. 下标赋值
<!--第⼀种：下标赋值-->
<bean id="user" class="pojo.User">
<constructor-arg index="0" value="qdy学Java"/>
</bean>
2. 通过类型创建
<!--第⼀种：通过类型创建，不建议使⽤-->
<bean id="user" class="pojo.User">
<constructor-arg type="java.lang.String" value="qidayang"/>
</bean>
3.参数名
<!--第三种⽅式：直接通过参数名创建-->
<bean id="user" class="pojo.User">
<constructor-arg name="name" value="其打样"/>
</bean>
总结：在配置⽂件加载的时候，容器中管理的对象就已经初始化了!
4、Spring配置
4.1、别名
<!--如果添加了别名，我们也可以通过别名获取这个对象-->
<alias name="user" alias="userNew"/>
4.2、Bean的配置
<!--id：bean的唯⼀标识符，也就是我们学的对象名
class：bean所对应的全限定名：包名+类名
name：也是别名,⽽且name可以去多个别名-->
<bean id="userT" class="pojo.UserT" name="userTNew,userTNew2 u3;u4">
<constructor-arg name="name" value="xiahouxue"/>
</bean>
## 4.3import
这个import，⼀般⽤于团队开发使⽤，他可以将多个配置⽂件，导⼊合并为⼀个!
假设，现在项⽬中有多个⼈开发，这三个⼈复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利⽤import将所有⼈的l合并为⼀个总的!
- 张三
- 李四
- 王五
- l
```xml
<import resource="l"/>
<import resource="l"/>
使⽤的时候，直接使⽤总的配置就可以了！
5、依赖注⼊（DI）
5.1、构造器注⼊
前⾯已经说过
5.2、Set⽅式注⼊【重点】
依赖注⼊：Set注⼊！
依赖：bean对象的创建依赖于容器！
注⼊：bean对象中的所有属性，由容器来注⼊！【环境搭建】
1.复杂类型
2.真实测试对象
5.3、扩展⽅式注⼊
实体类
pojo;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
}
pojo;
import java.util.*;
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 Properties 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;
ssm框架技术简介}
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", address=" + String() +
", books=" + String(books) +
", hobbys=" + hobbys +
", card=" + card +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + info +
'}';
}
}
测试类
pojo.Student;
import t.ApplicationContext;
import t.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("l"); Student student = (Student) Bean("student");
System.out.String());
}
/*Student{
name='qdy',
address=Address{address='厦门'}, books=[红楼梦, 西游记, ⽔浒传],
hobbys=[听歌, 敲代码, 看电影], card={⾝份证=1234567890, 银⾏卡=1234345234, =},
games=[lol, 王者, 吃鸡],
wife='null',
info={学号=31, 性别=男, 年龄=19}
}*/
}
完善注⼊信息
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="/schema/beans"
xmlns:xsi="/2001/XMLSchema-instance"
xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd"> <bean id="address" class="pojo.Address">
<property name="address" value="厦门"/>
</bean>
<bean id="student" class="pojo.Student">
<!--第⼀种：普通值注⼊-->
<property name="name" value="qdy"/>
<!--第⼆种：bean注⼊-->
<property name="address" ref="address"/>
<!--第三种：数组注⼊：ref-->
<property name="books" >
<array>
<value>红楼梦</value>
<value>西游记</value>
<value>⽔浒传</value>
</array>
</property>
<!--List-->
<property name="hobbys">
<list>
<value>听歌</value>
<value>敲代码</value>
<value>看电影</value>
</list>
</property>
<!--Map-->
<property name="card">
<map>
<entry key="⾝份证" value="1234567890"/>
<entry key="银⾏卡" value="1234345234"/>
<entry key="" value=""/>
</map>
</property>
<!--Set-->
<property name="games">
<set>
<value>lol</value>
<value>王者</value>
<value>吃鸡</value>
</set>
</property>
<!--null-->
<property name="wife" >
<null/>
</property>
<!--Properties-->
<property name="info">
<props >
<prop key="性别">男</prop>
<prop key="学号">31</prop>
<prop key="年龄">19</prop>
</props>
</property>
</bean>
</beans>
5.4、bean的作⽤域
1.单例模式(Spring默认机制)
1 <bean id="user2" class="pojo.user" c:age="18" c:name="狂神"
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论