Spring(Spring FrameWork)
Spring是一个开源框架，最早由Rod Johnson发起 Spring为简化企业级开发而生 使用Spring开发可以将Bean对象交给Spring容器来管理 这样使得很多复杂的代码在Spring中开发会变得优雅简洁 有效的降低代码的耦合度 极大的方便项目的后期维护 升级 和扩展
概述：
Spring是一个轻量级控制反转(IOC)和面向切面(AOP)为核心的容器框架
正转
|-------------|---------|--------------|-------|----------|
| Person.java | javac → | Person.class | new → | Person对象 |
第一个Spring程序（IOC案例）
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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--下面这句话等同于 Users user=new User();告诉Spring这个com.spring.pojo.Users类交给你管理了-->
<bean id="user" class="com.spring.pojo.Users"></bean>
</beans>
java
@Data
public class Users implements Serializable {
private int id;
private String uname;
private String pwd;
}
java
public class Demo {
//控制正转的方式
@Test
public void run1(){
Users user = new Users();
user.setId(1);
user.setUname("张三");
user.setPwd("333");
System.out.println(user);
}
//Spring中的控制反转技术(简称IOC技术)
@Test
public void run2(){
//加载spring.xml配置文件
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
//通过id从spring容器的对象缓存池中取bean(Users)对象
//ac.getBean("user");//这时对象会被自动提升为Object对象 需要强转回来
Users user =(Users) ac.getBean("user");
user.setId(1);
user.setUname("妮妮");
user.setPwd("0105");
System.out.println(user);
}
}基于xml映射文件中 bean标签的属性注入
java
@Data
public class Users implements Serializable {
private int id;
private String uname;
private String pwd;
//持有Clazz 引用数据类型
private Clazz clazz;
private Account account;
}
java
public class Clazz implements Serializable {
private String cname;
private int room;
public Clazz() {
}
public Clazz(String cname, int room) {
this.cname = cname;
this.room = room;
}
public String getCname() {
return cname;
}
public void setCname(String cname) {
this.cname = cname;
}
public int getRoom() {
return room;
}
public void setRoom(int room) {
this.room = room;
}
@Override
public String toString() {
return "Clazz{" +
"cname='" + cname + '\'' +
", room=" + room +
'}';
}
}
java
/*其他数据类型的注入*/
public class Data implements Serializable {
private String[] arr;
private List<Integer> list;
private Set set;
private Map map;
private Properties properties;
public Data() {
}
public Data(String[] arr, Properties properties, Map map, Set set, List<Integer> list) {
this.arr = arr;
this.properties = properties;
this.map = map;
this.set = set;
this.list = list;
}
public String[] getArr() {
return arr;
}
public void setArr(String[] arr) {
this.arr = arr;
}
public List<Integer> getList() {
return list;
}
public void setList(List<Integer> list) {
this.list = list;
}
public Set getSet() {
return set;
}
public void setSet(Set set) {
this.set = set;
}
public Map getMap() {
return map;
}
public void setMap(Map map) {
this.map = map;
}
public Properties getProperties() {
return properties;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
@Override
public String toString() {
return "Data{" +
"arr=" + Arrays.toString(arr) +
", list=" + list +
", set=" + set +
", map=" + map +
", properties=" + properties +
'}';
}
}
java
/*账户*/
public class Account {
private int aid;
private long money;
public Account() {
}
public Account(int aid, long money) {
this.aid = aid;
this.money = money;
}
public int getAid() {
return aid;
}
public void setAid(int aid) {
this.aid = aid;
}
public long getMoney() {
return money;
}
public void setMoney(long money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"aid=" + aid +
", money=" + money +
'}';
}
}
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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd"
default-autowire="byName"
>
<!--全局自动注入↑ 下面的每个bean都会自动注入-->
<!--下面这句话等同于 Users user=new User();告诉Spring这个com.spring.pojo.Users类交给你管理了-->
<bean id="user" class="com.spring.pojo.Users" scope="prototype">
<!--scope="singleton"单态模式 默认是这个 从bean取出的对象为 同一 对象-->
<!--scope="prototype"原型模式 从bean取出的对象为 不同 对象-->
<!--这个标签不仅可以声明类 也可以给该类赋值-->
<property name="id" value="1"></property>
<property name="uname" value="小依"></property><!--等同于user.setUname("小依");-->
<property name="pwd" value="111"></property>
</bean>
<!--通过set方法给属性注入值-->
<bean id="clazz" class="com.spring.pojo.Clazz">
<property name="cname" value="计算机应用科学"></property>
<property name="room" value="101"></property>
</bean>
<!--通过构造方法给属性注入值
相当于new Clazz("英语",201)-->
<bean id="claz" class="com.spring.pojo.Clazz">
<constructor-arg name="cname" value="英语"></constructor-arg>
<constructor-arg name="room" value="201"></constructor-arg>
</bean>
<!--给引用数据类型 持有的Clazz注入值-->
<bean id="user2" class="com.spring.pojo.Users" scope="prototype">
<!--scope="singleton"单态模式 默认是这个 从bean取出的对象为 同一 对象-->
<!--scope="prototype"原型模式 从bean取出的对象为 不同 对象-->
<!--这个标签不仅可以声明类 也可以给该类赋值-->
<property name="id" value="2"></property>
<property name="uname" value="小贰"></property>
<property name="pwd"><value/></property><!--<value/>或者<null/>空值注入-->
<property name="clazz" ref="clazz"></property><!--ref="clazz"关联clazz-->
</bean>
<bean id="data" class="com.spring.pojo.Data">
<property name="arr">
<array>
<value>北京</value>
<value>上海</value>
<value>广州</value>
<value>深圳</value>
</array>
</property>
<property name="list">
<list>
<value>10</value>
<value>20</value>
<value>30</value>
<value>40</value>
</list>
</property>
<property name="set">
<set>
<value>庐山</value>
<value>衡山</value>
<value>华山</value>
<value>庐山</value>
</set>
</property>
<property name="map">
<map>
<entry key="北京" value="010"></entry>
<entry key="广州" value="021"></entry>
<entry key="上海" value="020"></entry>
</map>
</property>
<property name="properties">
<props>
<prop key="省会">奉天</prop>
<prop key="菜品">烧烤</prop>
<prop key="特色">洗浴</prop>
</props>
</property>
</bean>
<!--局部自动注入-->
<bean id="account" class="com.spring.pojo.Account">
<property name="aid" value="11"></property>
<property name="money" value="12000"></property>
</bean>
<bean id="user3" class="com.spring.pojo.Users" scope="prototype" autowire="byType">
<!--autowire=""自动注入-->
<!--autowire="byName"根据名字account自动注入 名字对应Users中持有的名称private Account account;-->
<!--autowire="byType"根据类型com.spring.pojo.Account自动注入 注意:不能同时有两个com.spring.pojo.Account-->
<property name="id" value="3"></property>
<property name="uname" value="小山"></property>
<property name="pwd" value="333"></property>
<property name="clazz" ref="clazz"></property><!--ref="clazz"关联clazz-->
</bean>
</beans>基于注解的注入
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">
<!-- bean definitions here -->
<!--以下的标签是在当前文件被加载之后，扫描指定的包下所有的实体类-->
<context:component-scan base-package="com.spring.pojo"></context:component-scan>
</beans>
java
@Component/*这个注解是告诉spring容器，当你扫描com.spring.pojo包下所有的实体类时
捕捉该@Component注解 将含有这个注解的类 加载到容器中 并创建对象。。。*/
/*该注解相当于 Users users=new Users(); 当前并没有指定该类名称 默认首字母小写为该类名称 users*/
/*@Component("u") 指定该类名称为u*/
//@Scope("singleton")//默认 指定该类为单例模式
@Scope("prototype")//指定该类为多例(原形)模式
public class Users implements Serializable {
@Value("2")
private int id;
@Value("小贰")//给uname 赋值
private String uname;
@Value("222")
private String pwd;
//@Resource//引用类型的数据 根据bean的类型自动注入
@Autowired//自动注入 同@Resource一样 建议使用
private Clazz clazz;
//@Qualifier//声明注入 根据指定的bean的名字自动注入 要与@Autowired搭配使用 建议不用
@Resource//引用类型的数据 根据其类型自动注入
private Account account;
public Users() {
}
public Users(int id, String uname, String pwd, Clazz clazz, Account account) {
this.id = id;
this.uname = uname;
this.pwd = pwd;
this.clazz = clazz;
this.account = account;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public Clazz getClazz() {
return clazz;
}
public void setClazz(Clazz clazz) {
this.clazz = clazz;
}
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
@Override
public String toString() {
return "Users{" +
"id=" + id +
", uname='" + uname + '\'' +
", pwd='" + pwd + '\'' +
", clazz=" + clazz +
", account=" + account +
'}';
}
}
java
/*账户*/
@Component(value = "account")//括号内的value可以省略
public class Account {
@Value("101")
private int aid;
@Value("12000")
private long money;
public Account() {
}
public Account(int aid, long money) {
this.aid = aid;
this.money = money;
}
public int getAid() {
return aid;
}
public void setAid(int aid) {
this.aid = aid;
}
public long getMoney() {
return money;
}
public void setMoney(long money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"aid=" + aid +
", money=" + money +
'}';
}
}
java
public class Demo {
@Test
public void run1(){
ApplicationContext ca = new ClassPathXmlApplicationContext("Spring.xml");
Users users =(Users) ca.getBean("users");
users.setId(1);
users.setUname("小依");
users.setPwd("111");
users.setClazz(new Clazz("计算机",101));
users.setAccount(new Account(1,12000));
System.out.println(users);
}
@Test
public void run2(){
ApplicationContext ca = new ClassPathXmlApplicationContext("Spring.xml");
Users users =(Users) ca.getBean("users");
System.out.println(users);
}
}Spring的IOC(注解)
**@Component：**表示当前修饰的类交给Spring容器管理 修饰一个类 将其交给Spring容器
与@Component相同功能的 还有三个衍生注解 都是用来修饰类：
**@Repository：**添加在mapper的接口类上(数据访问层)
**@Service：**添加在Service实现类上(业务层)
**@Controller：**添加在Controller类上(控制层)
**@Configration：**添加在用于配置信息的类上(SpringBoot中自动配置)
使用场景：
**XML:**可以使用在任何场景 开发中用来注入框架实例 基于xml操作的是.class文件
**注解:**有些地方用不了 比如这个类不是自己写的(注解必须写在源代码上) 开发中用来注入自己写的Java类 基于注解操作的是源代码