Spring
- 简介：开发变简单，是一个轻量级非入侵式的框架
- 框架：一个模板
- 理念：实现有的技术更加简单的使用，整合了现有的技术框架
- SSM：SpringMVC，Spring，Mybatis
- 控制反转（IOC），面向切面编程（AOP）
- 支持事务的处理，对框架整合的支持
零、IOC理论推导
- UserDao接口
- UserDaoImpl 实现类
- UserService 业务接口
- UserServiceImpl 业务实现类
一、1第一个Spring项目学习
步骤
- 创建一个maven项目，删除原来有的src包
- 向pom.xml中导入依赖
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
</dependencies>
- 创建一个dao包，一个service包，这两个包同属于我们自己建的一个module
- 在dao里面，建立一个UserDao接口（interface），一个UserDaoImpl类
- 在service中，建立一个UserService接口（interface)，一个UserServiceImpl类
- 在上面的两个接口中都定义一个getUser方法
- 然后两个Impl 中都继承自己的接口，并且都调用dao层中的getUser方法
- 在test中，建立MyTest类，psvm，新建立服务层的impl，然后调用其方法
- 上述调用方法的革命性升华，就是建立set方法，利用接口上实现
- 之前，程序是主动创建对象，控制权在程序员手上，利用set注入后，程序不再具有主动性了，而是变成了被动的接受对象
private UserDao userDao;
//设置接口,利用set进行动态实现值的注入
//接口控制
public void setUserDao(UserDao userDao){
this.userDao = userDao;
}
- 以上正是IOC的原型，以后需要将程序交给谁都能够运行；主动权在service层
- 控制反转：获得依赖对象的方式反转了
- IOC可以利用XML配置，也可以使用注解，新版的Spring也可以零配置实现IOC
二、Hello Spring
- IOC是一种编程思想，由主动的编程变成被动的接受
- 我们不用在程序中去改动了，只需要在beans.xml中去修改就可以了
- ＩＯＣ：一句话，对象由Spring来创建，管理，装配！！
- Hello对象是谁创建的？
hello对象由spring创建 - Hello对象的属性是怎么设置的？
hello对象的属性是由Spring容器设置的
↑↑↑这个过程叫做控制反转↑↑↑
- 控制：谁来控制对象的创建，传统应用程序需的对象是由程序本身控制创建的，使用Spring后，对象是Spring来创建的
- 反转：程序本身不创建对象，而变成被动的接受对象
- 依赖注入：就是利用ｓｅｔ方法来进行注入的
三、IOC创建对象的方式
spring-03-ioc2在这个module里面
- 使用无参构造创建对象，默认的！！
<bean id = "user" class="com.wk.pojo.User">
<property name="name" value ="djsa"/>
<property name="password" value ="123456"/>
</bean>
- 假设要使用有参构造创建对象（如果我们仅仅设置一个值的话，那么我们输出的就只有一个）
- 下方是在beans.xml中的配置
- 有参构造3我们不建议使用，因为类型不能够相同，否则不能同时注册
- 在pojo的User中我们需要getset
- 在MyTest中我们需要这样做↓
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user");
user.show();
<!-- 有参构造1- 下标索引赋值-->
<bean id ="user" class="com.wk.pojo.User">
<constructor-arg index ="0" value = "wk"/>
<constructor-arg index ="1" value = "123456"/>
</bean>
<!-- 有参构造2- 直接通过参数名设置-->
<bean id = "user" class = "com.wk.pojo.User">
<constructor-arg name="name" value="wk"/>
<constructor-arg name="password" value = "123456"/>
</bean>
<!-- 有参构造3- 通过类型设置-->
<bean id ="user" class="com.wk.pojo.User">
<constructor-arg type="java.lang.String" value ="kw"/>
</bean>
- spring容器，相当于婚介网站
注意：我们在beans.xml中在创建一个UserT，但我们在使用的时候，只是使用User,但是我们发现spring也帮我们注册了UserT
总结：在配置文件加载的时候，容器（context）中管理的对象就已经初始化了
四、Spring配置
4.1 别名
<alias name = "user" alias = "saoda"/>
4.2 Bean的配置
- id：bean 的唯一标识符，也就是相当于我们学的对象名
- calss ： bean对象所对应的全限定名： 包名 + 类型
- name ： 也是别名，而且name 可以同时取多个别名
4.3 import
一般用于团队开发使用，可以将多个配置文件，导入合并为一个
假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有的beans.xml合并为一个总的
五、ＤＩ依赖注入
5.1、构造器注入，前面已经说过了
5.2、 Set方式注入【重点】
- 依赖注入：Set注入！！
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性，有容器来注入
【环境搭建】
- 复杂类型
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
- 对象测试对象
public class Student {
private String name;
private Address address;
private String[] book;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private String wife;
private Properties info;
}
- 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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id = "student" class="com.wk.pojo.Student">
<!-- 第一种，普通值的注入，使用value-->
<property name="name" value="WK"/>
</bean>
</beans>
- 测试类
public class MyTest {
public static void main(String[] args) {
ApplicationContext Context = new ClassPathXmlApplicationContext("beans.xml");
Student student =(Student) Context.getBean("student");
System.out.println(student.getAddress());
}
}
- 完善注入信息
<?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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id = "address" class = "com.wk.pojo.Address">
<property name="address" value="海南"/>
</bean>
<bean id = "student" class="com.wk.pojo.Student">
<!-- 第一种，普通值的注入，使用value-->
<property name="name" value="WK"/>
<!-- 第二种，Bean注入，使用ref-->
<property name = "address" ref="address"/>
<!-- 数组注入，ref-->
<property name="book" >
<array>
<value>红楼</value>
<value>西游</value>
<value>水壶</value>
<value>水壶</value>
</array>
</property>
<!-- List注入-->
<property name="hobbys">
<list>
<value>听听</value>
<value>玩游戏</value>
</list>
</property>
<!-- Map-->
<property name="card">
<map>
<entry key = "身份证" value="626+12+232"/>
<entry key = "银行卡" value="053852138"/>
</map>
</property>
<!-- Set-->
<property name="games">
<set>
<value>LOL</value>
<value>CF</value>
<value>FC</value>
</set>
</property>
<!-- null-->
<property name="wife">
<null/>
</property>
<!-- Properties-->
<property name="info">
<props>
<prop key="学号">20190525</prop>
<prop key="性别">男</prop>
<prop key="姓名">张三</prop>
</props>
</property>
</bean>
</beans>
5.3、其他方式
- 使用P方法
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id = "user" class = "com.wk.pojo.User" p:name = "wk" p:age="18"/>
</beans>
- 单独测试一下
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user = context.getBean("user",User.class);
System.out.println(user);
}
- 提供测试的类
public class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
- 使用c方法
<?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:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- p明星空间注入，可以直接注入属性的值：property-->
<bean id = "user" class = "com.wk.pojo.User" p:name = "wk" p:age="18"/>
<!-- c命名空间注入，通过构造器注入：construct-args-->
<bean id = "user2" class = "com.wk.pojo.User" c:age="18" c:name="张无忌"/>
</beans>
- 测试：
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user = context.getBean("user2",User.class);
System.out.println(user);
}
- 注意：p命名和c命名不能直接使用，需要导入xml约束
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
5.4、bean的作用域
- 单例模式：（Spring默认的机制）
<bean id = "user" class = "com.wk.pojo.User" p:name = "wk" p:age="18" scope="singleton" />
- 原型模式：每次从容器中get的时候，都会产生一个新的对象
<bean id = "user2" class = "com.wk.pojo.User" c:age="18" c:name="张无忌" scope="prototype"/>
- 其余的request、session、application这些只能在web开发中使用到
六、Bean的自动装配
- 自动装配是spring满足bena依赖的一种方式
- spring会在上下文中自动寻找，并自动给bean装配属性
- 在spring中有三种自动装配的方式
- 在xml中显示的配置
- 在java中显示配置
- 隐式的自动装配bean 【重要！】
6.1、测试
环境：一个人有狗和猫宠物，并且都能让他们叫
6.2、ByName自动装配
- 原理：ByName会在我们自己设置的容器中寻找，和自己对象set方法后面的值对应的bean的名称
- 原来
<bean id = "people" class="com.wk.pojo.People">
<property name="cat" ref="cat"/>
<property name="dog" ref="dog"/>
<property name="name" value="Nike的编程"/>
</bean>
- 现在（使用了 byname 之后）
<bean id = "people" class="com.wk.pojo.People" autowire="byName">
<property name="name" value="Nike的编程"/>
</bean>
- 弊端：只能够严格按照名字来，如果将dog改成了dog22，那么将报错
6.3、ByType自动装配
- 原理：ByName会在我们自己设置的容器中寻找，和自己对象的属性类型相对应的bean的名称
- 代码如下
<bean id = "cat" class = "com.wk.pojo.Cat"/>
<bean id = "dog22" class = "com.wk.pojo.Dog"/>
<bean id = "people" class="com.wk.pojo.People" autowire="byType">
<property name="name" value="Nike的编程"/>
</bean>
- 弊端与：这里dog22是dog类型，所以虽然名字我们对不上，但是类型可以；弊端同一个类型，只能有一个
- 优势：因为是根据类型来的，所以我们可以不给bean id 赋值，将 id = “” 删掉即可
6.4、使用注解实现自动装配
使用须知：
- 导入约束
- 配置注解的支持
<?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>
- 一定注意：后面的 context:annotation-config/注解的支持
@Autowired
直接在属性上使用即可；也可以在set上使用
使用了之后，连set方法都不需要了，前提是你这个自动装配的属性在IOC（spring）容器中存在，且符合名字byname
科普：
- @nullable：可以为空
public @interface Autowired {
boolean required() default true;
}
@qualifier可以让在一个类型的多个beanid中指定一个
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier（value=“XXX”）去配置@Autowired的
@Resource注解，可以说是上面的集合，先找id，如果没有再找类型。
小结：
@Resource和@Autowired的区别：
- 都是用来自动装配的
- @A是通过byname装配的
- @R默认name，如果找不到名字呢么通过byType实现，如果都找不到，那么就会报错
-
八、使用注解开发
在Spring4之后，要是用注解开发，必须要保证aop的包导入了
使用注解需要导入context约束，增加注解的支持
-
bean
-
属性如何注入
@Component
public class User {
public String name ;
// 相当于 <property name = "name" value="WKWK"/>，如果是简单地话
//注入到set方法上也可以
@Value("WKWK")
public void setName(String name){
this.name=name;
}
}
- 衍生的注解
@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层- dao【@Repository】
- service【@Service】
- controller【@Controller】
这四个注解的功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
- 自动装配置
@Autowired ： 自动装配通过类型，名字 如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier（value=“xxx”）
@Nullable 字段标记了这个注解， 说明这个字段可以为null
@Resource ： 自动装配通过名字， 类型
- 作用域
@Component
@Scope("singleton")//prototype 标注是单例还是原型
public class User {
public String name ;
// 相当于 <property name = "name" value="WKWK"/>，如果是简单地话
//注入到set方法上也可以
@Value("WKWK")
public void setName(String name){
this.name=name;
}
}
- 小结
xml与注解：
- xml更加万能，使用任何场合，利于维护
- 注解不是自己的类就不能使用，不利于维护
xml与注解最佳实践
- xml用来管理bean
- 注解只负责完成属性的注入；
- 我们在使用的过程中，只需要注意一个问题，必须让注解生效，就需要开启注解的支持
@Component
@Scope("singleton")//prototype 标注是单例还是原型
public class User {
public String name ;
// 相当于 <property name = "name" value="WKWK"/>，如果是简单地话
//注入到set方法上也可以
@Value("WKWK")
public void setName(String name){
this.name=name;
}
}
九、使用Java的方式配置spring
我们不是用Spring的xml配置，全由java来做
javaconfig是spring的
十、代理模式
这就是Springaop的底层【springaop和springmvc】
代理模式的分类
- 静态代理
- 动态代理
10、1静态代理
角色分析：
- 抽象角色：Rent是接口或抽象类
- 真实角色：房东
- 代理角色：中介
- 客户：访问代理对象的人
代码步骤：
- 接口
public interface Rent {
public void rent();
}
- 真实角色
public class Host implements Rent{
public void rent() {
System.out.println("zufanglele");
}
}
- 代理角色
public class Proxy implements Rent {
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
public void rent(){
seeHouse();
host.rent();
hetong();
fare();
}
//看房
public void seeHouse(){
System.out.println("中介带人看房");
}
//签合同
public void hetong(){
System.out.println("签合同");
}
//收中介费
public void fare(){
System.out.println("收中介费");
}
}
- 客户端访问代理角色
public class Client {
public static void main(String[] args) {
Host host = new Host();
// host.rent();
//代理，中介帮房东租房子，代理会有一些附属操作
Proxy proxy = new Proxy(host);
//直接找中介租房即可
proxy.rent();
}
}
好处：
- 让房东更加省心，自己只有租房即可，其他事物由中介完成
- 公共也就交给代理角色，实现业务的分工
- 公共业务发生拓展的时候，方便集中管理
缺点：
- 一个真实角色就会产生一个代理角色，效率低
10、2加深理解
10.3、动态代理
- 动态代理的角色跟静态代理一样
- 动态代理的代理类是动态生成的，不是我们直接写好的
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
* 基于接口–JDK动态代理
* 基于类：cglib
* java字节码实现
需要了解两个类：
十一、AOP
11.1 什么是AOP
11.2 AOP在Spring中的作用
方式一：使用spring的 ＡＰＩ 接口【主要是SpringAPI接口实现】
<!-- 注册bean-->
<bean id = "userService" class="com.wk.pojo.UserServiceImpl"/>
<bean id = "log" class="com.wk.log.Log"/>
<bean id = "afterLog" class="com.wk.log.AfterLog"/>
<!-- 配置AOP:徐涛导入aop的约束-->
<aop:config>
<!-- 切入点: expression : 表达式. execution(要执行的位置！****）-->
<aop:pointcut id="pointcut" expression="execution(* com.wk.pojo.UserServiceImpl.*(..))"/>
<!-- 执行环绕增加，,将log切入到上面的pointcut-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
方式二：自定义来实现APO【主要是切面定义】
<bean id="diy" class="com.wk.diy.DiyPointCut"/>
<aop:config>
<aop:aspect ref="diy">
<aop:pointcut id="point" expression="execution(* com.wk.pojo.UserServiceImpl.*(..))"/>
<aop:before method="before" pointcut-ref="point"/>
<aop:after method="after" pointcut-ref="point"/>
</aop:aspect>
</aop:config>
方式三：使用注解来做
- xml的配置
- 代码中的实现
5604
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
