2021-06-12

最新推荐文章于 2024-07-22 08:55:10 发布

陈平安_码来

最新推荐文章于 2024-07-22 08:55:10 发布

阅读量139

点赞数 1

文章标签： spring

原文链接：https://www.kuangstudy.com/bbs/1400287798262566914

版权

Spring

IoC创建对象的方式

使用无参构造创建对象，默认
假如我们要使用有参构造创建对象

下标赋值

<!--第一种，下标赋值-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="狂神说java" />
</bean>

类型

<!--第二种，通过类型创建，不建议使用-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg type="java.lang.String" value="java" />
</bean>
参数名

通过参数名设置

<!--第三种，直接通过参数名来设置-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="java" />
</bean>

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了。

Spring配置

alias别名

<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="java" />
</bean>
<!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="aksur" />

Bean配置

<!--
id:bean的唯一标识符，也就是相当于我们选的对象名
class：bean对象所对应的全限定名
name:取别名，而且name可以同时取多个别名
-->
<bean id="user" class="com.kuang.pojo.User" name="user2,user3">
    <constructor-arg name="name" value="java" />
</bean>

import

这个import，一般用于团队开发使用，他可以将多个配置文件，导入合并为一个

项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！
总配置：applicationContext.xml
成员1：beans.xml
成员2：beans1.xml

需要在总的配置applicationContext.xml中进行导入

<import resource="beans.xml" />
<import resource="beans1.xml" />

依赖注入

依赖注入：

依赖：bean对象的创建依赖于容器
注入: bean对象中的所有属性，由容器来注入

构造器注入

上面已经讲解

通过set方式注入【重点】

实体类

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;
    }
    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=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

beans.xml

<bean name="address" class="com.kuang.pojo.Address">
        <property name="address" value="西安" />
    </bean>
    <bean name="student" class="com.kuang.pojo.Student">
        <!--第一种，普通值注入，value-->
        <property name="name" value="ting"/>
        <!--第二种，bean注入，ref-->
        <property name="address" ref="address"/>
        <!--第三种，数组注入-->
        <property name="books">
            <array>
                <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="111111111111"/>
                <entry key="小兰" value="123111111111"/>
                <entry key="瑶瑶" value="234555555555" />
            </map>
        </property>
        <!--set注入-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
            </set>
        </property>
        <!--Properties注入-->
        <property name="info">
            <props>
                <prop key="学号">20190978</prop>
                <prop key="姓名">kuangkuang</prop>
            </props>
        </property>
        <!--
        null值
        空值：<property name="wife" value=" "></property>
        -->
        <property name="wife">
            <null/>
        </property>
    </bean>

拓展方式注入

p命名空间注入，可以直接注入属性的值：property

c命名空间注入，通过构造器注入：construct-args

我们可以使用p命名空间和c命名空间进行注入

官方文档：

注意点：p命名和c命名空间不能直接使用，需要导入xml约束

 <!--p命名空间注入，可以直接注入属性的值：property-->
    <bean id="user" class="com.kuang.pojo.User" p:name="kuang" p:age="12"/>
    <!--c命名空间注入，通过构造器注入：construct-args-->
    <bean id="user2" class="com.kuang.pojo.User" c:name="ting" c:age="23" />
    <!--单例模式-->
    <bean id="user3" class="com.kuang.pojo.User" c:name="ting" c:age="23" scope="singleton" />
    <!--原型模式-->
    <bean id="user4" class="com.kuang.pojo.User" c:name="ting" c:age="23" scope="prototype" />

Bean作用域

单例模式 singleton(Spring默认机制) 并发延迟问题
原型模式：每次从容器中get时，都会产生一个新对象

request session application 这些个只能在web开发中使用到

Bean的自动装配autowired

自动装配是Spring满足bean依赖的一种方式
Spring会在上下文中自动寻找，并自动给bean装配属性！

在Spring中有三种装配方式

01.在xml中显示配置
02.在java中显示配置
03.隐式的自动装配bean【重要】

测试

环境搭建:
一个人两个宠物

public class User {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;
    public Cat getCat() {
        return cat;
    }
    public void setCat(Cat cat) {
        this.cat = cat;
    }
    public Dog getDog() {
        return dog;
    }
    public void setDog(Dog dog) {
        this.dog = dog;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "User{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + name + '\'' +
                '}';
    }
}

<?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/>
    <!--
    第一种，手动配置
    <bean id="cat" class="com.kuang.pojo.Cat" />
    <bean id="dog" class="com.kuang.pojo.Dog" />
    <bean id="user" class="com.kuang.pojo.User">
        <property name="name" value="ting" />
        <property name="cat" ref="cat" />
        <property name="dog" ref="dog" />
    </bean>
    第二种，通过名字name自动配置
    <bean id="cat" class="com.kuang.pojo.Cat" />
    <bean id="dog" class="com.kuang.pojo.Dog" />
    <bean id="user" class="com.kuang.pojo.User" autowire="byName">
        <property name="name" value="ting" />
    </bean>
    第三种，通过类型type自动配置
    <bean id="cat" class="com.kuang.pojo.Cat" />
    <bean id="dog" class="com.kuang.pojo.Dog" />
    <bean id="user" class="com.kuang.pojo.User" autowire="byType">
        <property name="name" value="ting" />
    </bean>
    第四种，通过@Autowired和@Qualifier("dog22")
    <bean id="cat" class="com.kuang.pojo.Cat" />
    <bean id="dog11" class="com.kuang.pojo.Dog" />
    <bean id="dog22" class="com.kuang.pojo.Dog" />
    <bean id="user" class="com.kuang.pojo.User">
        <property name="name" value="ting" />
    </bean>
    第五种，通过@Resource和@Resource(name = "dog22")
    <bean id="cat" class="com.kuang.pojo.Cat" />
    <bean id="dog11" class="com.kuang.pojo.Dog" />
    <bean id="dog22" class="com.kuang.pojo.Dog" />
    <bean id="user" class="com.kuang.pojo.User">
        <property name="name" value="ting" />
    </bean>
    -->
    <bean id="cat" class="com.kuang.pojo.Cat" />
    <bean id="dog" class="com.kuang.pojo.Dog" />
    <bean id="user" class="com.kuang.pojo.User">
        <property name="name" value="ting" />
    </bean>
</beans>

byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid

byType: 会自动在容器上下文中查找，和自己对象属性类型相同的beanid，必须保证bean中类型唯一

小结：
byName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致

byType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致

使用注解实现自动装配

JDK1.5支持的注解
Spring2.5支持的注解

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

要使用注解须知：

01.导入约束 context约束
02.配置注解的支持 <context:annotation-config />
@Autowired

直接在属性上使用即可，也可以在set方式上使用
使用Autowired我们可以不用编写Set方法了，前提是你这个自动装配的属性在IOC(Spring)容器中存在，且符合名字byName
@Autowired(required=false) 如果显示的定义了Autowired的required属性为false,说明这个对象可以为null，否则不允许为空；

@Nullable 字段标记了这个注解，说明这个字段可以为null

如果 @Autowired 自动装配的环境比较复杂，自动装配无法通过一个注解（@Autowired）完成的时候，我们可以使用@Qualifier去配合 @Autowired的使用，指定一个唯一的bean对象注入。
@Autowired
@Qualifier(value=”dog”)

自动装配
import javax.annotation.Resource
@Resource
@Resource(name=”cat22”)

小结：

@Resource和@Autowired的区别
都是用来自动装配的，都可以放在属性字段上
@Autowired通过byType的方式实现，而且必须要求这个对象存在
@Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现，如果两个都找不到的情况下，就报错。
执行顺序不同：@Autowired通过byType的方式实现。@Resource默认通过byName方式实现。

使用注解开发

Spring4之后，要使用注解开发，必须保证aop的包导入；
在这里插入图片描述
使用注解需要导入context约束，增加注解支持；

<context:annotation-config />

01.bean
applicationContext.xml

<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.kuang.pojo" />
<!--注解驱动的支持-->
<context:annotation-config />

pojo

//等价于<bean id="user" class="com.kuang.pojo.User" />
//@Component组件
//id默认为pojo类的小写
@Component
public class User{
    public String name="琴儿";
}

01属性如何注入

//等价于<bean id="user" class="com.kuang.pojo.User" />
//@Component组件
//id默认为pojo类的小写
@Component
public class User{
    //等价于<property name="name" value="kuangshen" />
    @Value("kuangshen")
    public String name;
    public void setName(String name) {
        this.name = name;
    }
}

@Component
public class User{
    public String name;
    @Value("kuangshen")
    public void setName(String name) {
        this.name = name;
    }
}

01.衍生的注解

@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层。

pojo 【@Repository】
dao 【@Repository】
service 【@Service】
controller 【@Controller】
这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean

UserDao.java

@Repository
public class UserDao {
}

service

@Service


public class UserService {
}

controller

@Controller

public class UserController {

}

自动装配置

- @Autowired:自动装配通过类型，名字
     如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value="xxx")
- @Nullable 字段标记了这个注解，说明这个字段可以为null
- @Resource : 自动装配通过名字，类型

作用域

@Component
@Scope("singleton")
public class User{
    public String name;
    @Value("kuangshen")
    public void setName(String name) {
        this.name = name;
    }
}

01小结
xml与注解

xml更加万能，适用于任何场合，维护简单方便
注解，不是自己的类使用不了，维护相对复杂

最佳实践

xml用来管理bean
注解只负责完成属性的注入
+我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持

<context:component-scan base-package="com.ting" />
<context:annotation-config/>

使用Java的方式配置Spring

官方文档： Java-based Container Configuration中介绍

我们现在要完全不使用Spring的xml配置了，全权交给Java来做

JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能。

com.kuang.config

KuangConfig

/*@Configuration这个也会被Spring容器托管，注册到容器中，因为它本来就是一个@Component;
@Configuration代表这是一个配置类，和我们之前看到的beans.xml
*/
@Configuration
@ComponentScan(“com.kuang.pojo”)
@Import(KuangConfig2.class)
public class KuangConfig{
/*注册一个bean,就相当于我们之前写的一个bean标签，
这个方法的名字，就相当于bean标签中的id属性
这个方法的返回值，就相当于bean标签中的class属性
*/
@Bean
public User getUser() {
return new User(); //就是返回要注入到bean的对象
}
}
KuangConfig2.java

@Cofiguration
public class KuangConfig2{
}
User.java

@Component
public class User{
private String name;
public String getName() {
return name;
}
@Value(“QINJIANG”)
public void setName(String name){
this.name = name;
}
@Override
public String toString() {
return “User{” + “name=’” + name + ‘’’ + ‘}’;
}
}
public static void main(String[] args) {
//如果完全使用了配置类方式去做，我们就只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载。
ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.class);
User getUser = (User)context.getBean(“getUser”);
System.out.println(getUser.getName());
}
SpringBoot项目搭建
File - New Project - Spring Initializr - next - next - finish

删除.mvn .gitignore HELP.md mvnw mvnw.cmd

代理模式
中介：

为什么要学习代理模式？

因为这就是SpringAOP的底层
面试高频 SpringAOP SpringMVC
代理模式分类：

静态代理
动态代理
静态代理
角色分析：

抽象角色：一般会使用接口或者抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
客户：访问代理对象的人

代码步骤：

接口
真实角色
代理角色
客户端访问代理角色
代理模式的好处：

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务就交给代理角色，实现了业务分工
公共业务发生扩展的时候，方便集中管理
代理模式的缺点：
一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低
案例代码：

租房：接口

public interface Rent{
public void rent();
}
房子主人

public class Host implements Rent{
public void rent() {
System.out.println(“我要出租房”);
}
}
代理

public class Proxy implements Rent{
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
public void rent() {
host.rent();
}
}
顾客

Host host = new Host();
Proxy proxy = new Proxy(host);
proxy.rent();
静态代理再理解
UserDao
UserDaoImpl
UserDaoProxy
Client

初始AOP

动态代理
角色分析：

抽象角色：一般会使用接口或者抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
客户：访问代理对象的人
动态代理的代理类是动态生成的，不是我们直接写好的

动态代理分为两大类：

基于接口的动态代理
- JDK动态代理[讲]
基于类的动态代理
- cglib
- java字节码实现：javasist
  需要了解两个类:Proxy、 InvocationHandler：调用处理程序

代理类：

//自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
/*
Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class<?>[] {Foo.class},handler);
*/
// 被代理的接口
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
}
//生成得到代理类
public Object getProxy() {
return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
}
//处理代理实例，并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
seeHost();
//动态代理的本质，就是使用反射机制实现的
Object result = method.invoke(rent, args);
return result;
}
public void seeHost() {
System.out.println(“看房子”);
}
}
动态代理的好处：

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务就交给代理角色，实现了业务分工
公共业务发生扩展的时候，方便集中管理
一个动态代理类代理的是一个接口，一般就是对应的一类业务
一个动态代理类可以代理多个类，只要是实现了同一个接口即可
//自动生成代理类
/*
Proxy 生成动态代理实例
InvocationHandler 调用处理程序并返回结果
/
public class ProxyInvocationHandler implements InvocationHandler {
/
Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class<?>[] {Foo.class},handler);
*/
// 被代理的接口
private Object target;
public void setTarget(Object target) {
this.target = target;
}
//生成得到代理类
public Object getProxy() {
return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
//处理代理实例，并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log(method.getName());
//动态代理的本质，就是使用反射机制实现的
Object result = method.invoke(target, args);
return result;
}
//代理额外的方法
public void log(String getMethod) {
System.out.println("【debug】" + getMethod + “方法被调用了” );
}
}
AOP
什么是AOP
AOP(Aspect Oriented Programming)意为：面向切面编程，通过预编译方法和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP在Spring中的作用
提供声明式事务：允许用户自定义切面

横切关注点：跨越应用程序的多个模块或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志、安全、缓存、事务等…
切面（ASPECT）: 横切关注点被模块化的特殊对象，即它是一个类log
通知（Advice）:切面必须要完成的工作，即，它是类中的一个方法。
目标（Target）:被通知对象
代理（Proxy）:向目标对象应用通知之后创建的对象。
切入点（PointCut）: 切面通知执行的“地点”的定义。
连接点（JoinPoint）:与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5中类型的Advice:

即AOP在不改变原有代码的情况下，去增加新的功能。

方式一：使用Spring实现Aop
方式一：使用Spring的API接口MethodBeforeAdvice实现

使用AOP，需要导入一个依赖包：

org.aspectj aspectjweaver 1.9.6 public class Log implements MethodBeforeAdvice { /* method: 要执行的目标对象的方法 args:参数 target:目标对象 */ public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了"); } } AfterReturningAdvice接口

配置文件：

<!--注册bean-->
<bean id="userService" class="com.kuang.service.UserServiceImpl"/>
<bean id="log" class="com.kuang.log.Log"/>
<bean id="afterLog" class="com.kuang.log.AfterLog" />
<!--配置aop：需要导入aop约束-->
<aop:config>
    <!--切入点：expression:表达式 execution(要执行的位置：* * * * *) 限定词 返回值类型 方法 参数-->
    <aop:pointcut id="pointcut" expression="execution(* com.tingzheng.service.UserServiceImpl.*(..))"/>
    <!--执行环绕增强-->
    <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut" />
</aop:config>

自定义来实现AOP
自定义来实现AOP[主要是切面定义]

diy - DiyPointCut

DiyPointCut

public class DiyPointCut {
public void before() {
System.out.println("==执行方法前=");
}
public void after() {
System.out.println("==执行方法后=");
}
}

aop:config

<aop:aspect ref=“diy”>

<aop:pointcut id=“point” expression=“execution(* com.tingzheng.service.UserServiceImpl.*())”/>

<aop:before method=“before” pointcut-ref=“point”/>
<aop:after method=“after” pointcut-ref=“point” />
</aop:aspect>
</aop:config>
方式三：使用注解实现
AnnotationPointCut

使用注解方式实现AOP

org.aspectj.lang.annotation.Before

//标注这个类是一个切面
@Aspect
public class AnnotationPointCut {
@Before(“execution(* com.kuang.service.UserServiceImpl.(…))")
public void before() {
System.out.println("==方法执行前=");
}
@After("execution( com.kuang.service.UserServiceImpl.(…))")
public void after() {
System.out.println(“方法执行后”)；
}
//在环绕增强中，我们可以给定义一个参数，代表我们要获取处理切入的点
@Around("execution( com.kuang.service.UserServiceImpl.*(…))”)
public void around(ProceedingJoinPoint jp) throws Throwable {
System.out.println(“环绕前”);
Signature signature = jp.getSignature(); //获取签名
//执行方法
Object proceed = jp.proceed();
System.out.println(“环绕后”)
System.out.println(proceed);
}
}
结果：
环绕前
=方法执行前=
=增加了一个用户
环绕后
=方法执行后=

applicationContext.xml

AOP是一个横向编程的思想，在不影响原来业务类的情况下，实现动态的增强。

陈平安_码来

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-06-12

SpringIoC创建对象的方式使用无参构造创建对象，默认假如我们要使用有参构造创建对象下标赋值<bean id="user" class="com.kuang.pojo.User"> <constructor-arg index="0" value="狂神说java" /></bean>类型<bean id="user" class
复制链接

扫一扫