Spring（上）-CSDN博客

本文链接：https://blog.csdn.net/xxmuq/article/details/115289577

Spring特性：控制反转和面向切面编程，轻量级框架。

面向切面编程（AOP）：在不影响源代码或者业务的情况下实现动态增强功能。主要用来进行事务控制。

适用于权限，缓存，日志，事务等场景。

在spring中实现AOP

1.导入aop依赖包

<dependencies>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.0</version>
        </dependency>
    </dependencies>

2.实现spring的API接口

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()+"被执行！");
    }
}

3.把bean注册到spring中

<bean id="log" class="com.log.Log"/>

4.配置aop：导入aop的约束

    <aop:config>
        <!--切入点-->
        <aop:pointcut id="pointcut" expression="execution(* com.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    </aop:config>

5.测试aop

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    //动态代理的是接口
    UserService userService = context.getBean("userservice", UserService.class);
    userService.add();
}

Spring常用注解

@Autowired：自动装配，通过类型，名字。
如果Autowired不能唯一自动装配 上属性，则需要通过@Qualifier(value="xxx" )

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

@Resource ：自动装配，通过名字，类型。

以下四个功能一样，组件，将类注册到spring容器中，装配bean。
pojo：@component
dao：@Repository
seervice：@Service
controller：@Controller

1、Spring

一个轻量级的控制反转（IOC）和面向切面编程（AOP）框架。
主要用于与其他技术进行整合，可将应用程序中的Bean组件实现低耦合关联，最终可以提高系统扩展和维护性。

导入相关依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.18</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.0</version>
</dependency>

2、IOC

控制反转：将对象的创建从程序员手中剥离，交由客户控制选择。Spring实现对对象的创建，管理，装配。

2.1、使用

2.1.1、实体类使用

创建pojo文件夹下实体类Hello

public class Hello {
    private String str;
}

配置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">
    <!--使用Spring创建对象，保存在容器中，作用等同于new 对象。
	id：对象名
	property：为属性设置值
	-->
    <bean id="hello" class="com.pojo.Hello">
        <!--name：属性名
		value：具体的值，基本数据类型
		-->
        <property name="str" value="Spring"/>
    </bean>
</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //获取bean，注意此处要强转类型
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());		//Hello(str=Spring)
    }
}

2.1.2、实现类使用

创建dao文件夹下文件

public interface UserDao {
    void getUser();
}

public class UserDaoImpl implements UserDao {
    public void getUser() {
        System.out.println("获取用户");
    }
}

public class MySQLUserDaoImpl implements UserDao{
    public void getUser() {
        System.out.println("MySQL获取用户");
    }
}

创建service文件夹下文件

public interface UserService {
    void getUser();
}

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    
    //使用注入的方式决定类的值
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void getUser() {
        userDao.getUser();
    }
}

配置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">
    <!--使用Spring创建对象，保存在容器中，作用等同于new 对象。
    id：对象名
    property：为属性设置值
    -->
    <bean id="UserDaoImpl" class="com.dao.UserDaoImpl"/>
    <bean id="MySQLUserDaoImpl" class="com.dao.MySQLUserDaoImpl"/>

    <bean id="UserServiceImpl" class="com.service.UserServiceImpl">
        <!--ref：引用容器中创建好的bean-->
        <property name="userDao" ref="UserDaoImpl"/>
    </bean>
</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //获取bean，注意此处要强转类型
        UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");
        userServiceImpl.getUser();
    }
}

2.2、IOC创建对象的方式

bean在getBean之前，也就是加载配置文件的时候就已经创建了，getBean只是获取。

构造器注入：

默认使用无参构造创建对象。

有参构造创建对象

1、创建实体类User

public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("name="+name);
    }
}

2、配置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="user" class="com.pojo.User">
        <!--方式一：下标赋值-->
        <constructor-arg index="0" value="小明"/>
        <!--方式二：类型赋值-->
        <constructor-arg type="java.lang.String" value="小明"/>
        <!--方式三：参数名赋值-->
        <constructor-arg name="name" value="小明"/>
    </bean>
</beans>

3、Spring配置说明

3.1、别名

<!--使用alias设置别名-->
<alias name="user" alias="user2"/>
<!--也可以直接在bean的name设置别名-->
<bean id="user" class="com.pojo.User" name="user3">

3.2、bean

<!--使用Spring创建对象，保存在容器中，作用等同于new 对象。
 id：对象名
 class：对象对应的类
 property：为属性设置值
 -->
<bean id="hello" class="com.pojo.Hello">
    <!--name：属性名
	value：具体的值，基本数据类型
	ref：引用容器中创建好的bean
    -->
    <property name="str" value="Spring"/>
</bean>

3.3、import

多人开发同一项目，可将多个配置文件合并为一个，一般是 applicationContext.xml 。

<import resource="beans1.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

4、DI

依赖注入：由容器创建对象，动态的将某个依赖关系注入到组件之中，将值注入到属性中，提升组件重用的频率。

4.1、构造器注入

参考2.2。

4.2、属性注入

利用set方法进行注入。

1、创建实体类

@Data
public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
}

//编写其中的Address类
@Data
public class Address {
    private String address;
}

2、属性注入

<?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.pojo.Address">
        <property name="address" value="广州"/>
    </bean>
    <bean id="student" class="com.pojo.Student">
        <!--普通属性-->
        <property name="name" value="aaa"/>
        <!--引用其他bean-->
        <property name="address" ref="address"/>
        <!--数组-->
        <property name="books">
            <array>
                <value>三国演义</value>
                <value>水浒传</value>
                <value>红楼梦</value>
            </array>
        </property>
        <!--list-->
        <property name="hobbies">
            <list>
                <value>听歌</value>
                <value>跑步</value>
                <value>游泳</value>
            </list>
        </property>
        <!--map-->
        <property name="card">
            <map>
                <entry key="身份证" value="123456789"/>
                <entry key="银行卡" value="987654321"/>
            </map>
        </property>
        <!--set-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>绝地求生</value>
            </set>
        </property>
        <!--null-->
        <!--<property name="wife" value=""/>-->
        <property name="wife">
            <null/>
        </property>
        <!--properties-->
        <property name="info">
            <props>
                <prop key="id">123123</prop>
                <prop key="sex">男</prop>
            </props>
        </property>
    </bean>
</beans>

4.3、命名空间注入

1、p命名空间注入

实体类

@Data
public class User {
    private String name;
    private int age;
}

配置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:p="http://www.springframework.org/schema/p"
       
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--p命名空间注入，要求有set方法和无参构造（要导入依赖）-->
    <bean id="user" class="com.pojo.User" p:name="小明" p:age="18"/>
</beans>

2、c命名空间注入

实体类

@Data
@AllArgsConstructor
public class User {
    private String name;
    private int age;
}

配置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:c="http://www.springframework.org/schema/c"
       
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--c命名空间注入，要求有有参构造方法（要导入依赖）-->
    <bean id="user" class="com.pojo.User" c:name="小明" c:age="18"/>
</beans>

5、Bean作用域

5.1、单例作用域

singleton：仅创建一个 singleton bean 的一个实例，所有与该 bean 定义匹配的 id 相同的 bean 的请求都会由 Spring 容器返回该特定的 bean 实例。
当定义一个 bean 定义并且其作用域为单例时，Spring IoC 容器会创建该 bean 定义定义的对象的一个实例。该单个实例存储在此类单例 bean 的缓存中，并且该命名 bean 的所有后续请求和引用返回缓存的对象。
单例作用域获得的两个对象是相同的。
Spring IoC 容器默认使用单例作用域，所以可以省略scope="singleton"。

<bean id="accountService" class="com.foo.DefaultAccountService"/>

<bean id="accountService" class="com.foo.DefaultAccountService" scope="singleton"/>

5.2、原型范围

prototype：每次对特定 bean 发出请求时，bean 部署的非单一原型范围都会导致创建一个新的 bean 实例。
将 Bean 注入到另一个 Bean 中，或者可以通过容器上的getBean()方法调用来请求它。
原型范围获得的两个对象是不相同的，即使是getBean()相同的bean。

<bean id="accountService" class="com.foo.DefaultAccountService" scope="prototype"/>

5.3、其余作用域

以下作用域仅在可感知网络的 Spring ApplicationContext上下文中有效，也就是 web 中。

作用域	生命周期
request	只在一次请求中有效。
session	只在一次会话中有效。
application	全局有效。

6、自动装配

Autowired：Spring可以自动在上下文中寻找和装配bean的属性。

6.1、环境装配

1、实体类

@Data
public class Cat {public void shout(){System.out.println("喵");}}

@Data
public class Dog {public void shout(){System.out.println("汪");}}

@Data
public class Person {
    private Cat cat;
    private Dog dog;
}

2、applicationContext.xml（其实就是 beans.xml，官方命名是 applicationContext.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="cat" class="com.pojo.Cat"/>
    <bean id="dog" class="com.pojo.Dog"/>
    <bean id="person" class="com.pojo.Person">
    </bean>
</beans>

6.2、byName

<bean id="person" class="com.pojo.Person" autowire="byName">

自动在容器上下文查找 bean 的 id 和对象属性 set 方法后面的值命名相同的实例。

例如public void setCat(Cat cat) {this.cat = cat;}，其中的 cat 与定义的 bean 的 id 为 cat 相同，就会自动装配。

6.3、byType

<bean id="person" class="com.pojo.Person" autowire="byType">

自动在容器上下文查找 bean 的 class 和对象属性类型相同的实例。

6.4、注解实现装配

@Autowired默认使用 byType，无法使用则使用 byName。

1、导入约束和配置注解支持

<?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
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">
    <!--配置注解支持-->
    <context:annotation-config/>
    
    <bean id="cat" class="com.pojo.Cat"/>
    <bean id="dog" class="com.pojo.Dog"/>
    <bean id="dog111" class="com.pojo.Dog"/>
    <bean id="person" class="com.pojo.Person"/>
</beans>

2、在属性上配置注解

当@Autowired的环境比较复杂（存在多个相同 class 的 bean）时，可以使用@Qualifier

@Data
public class Person {
    @Autowired
    private Cat cat;
    @Autowired
    //显示定义装配的属性 id
    @Qualifier(value = "dog111")
    private Dog dog;
}

7、注解开发

注解开发需要先导入aop的包，spring-webmvc 包含 aop。

导入 context 约束，增加注解支持。

<?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
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">
    <!--配置注解支持-->
    <context:annotation-config/>
    <!--自动扫描包，使对应包的注解生效-->
    <context:component-scan base-package="com"/>
</beans>

@Component      			//用于pojo，相当于在applicationContext.xml文件里注入了bean
@Scope("singleton")			//为这个bean设置作用域
public class User {
    @Value("aaa")			//为属性注入值
    private String name;
}

以下几个注解功能和@Component相同，用于不同文件
@Repository		用于dao
@Service		用于service
@Controller		用于controller

8、JavaConfig

可以不使用 spring 的 xml 来配置，交由 java 操作。

1、环境

//创建实体类
@Data
@Component
public class User {
    @Value("acaavs")
    private String name;
}

//配置bean
@Configuration			//代表一个配置类，作用类似applicationContext.xml
@Import(UserConfig2.class)	//整合其他配置类
public class UserConfig {
    @Bean				//相当于一个bean，id是方法名，class是方法的返回值
    public User getUser(){
        return new User();
    }
}

2、测试

public class MyTest {
    public static void main(String[] args) {
        //获取注解context
        ApplicationContext context = new AnnotationConfigApplicationContext(UserConfig.class);
        //getBean配置的方法名
        User user = context.getBean("getUser", User.class);
        System.out.println(user.getName());
    }
}