spring框架（一）

1、Spring框架：IoC和AOP

服务端三层开发：表现层、业务层、持久层 ssm, springboot, springcloud(微服务，治理组件)

Spring框架是一个流行的Java应用程序框架，它提供了许多功能来简化企业级应用程序的开发。其中，控制反转（Inversion of Control，IoC）和面向切面编程（Aspect-Oriented Programming，AOP）是Spring框架的两个重要概念。

1.控制反转（IoC）：将对象的创建权力反转给Spring框架

控制反转是一种设计原则，旨在将控制权从代码中提取出来，并交由外部容器或框架来管理。在传统的程序设计中，对象之间的依赖关系通常是在代码中硬编码的，这会导致代码之间的耦合度较高，不利于维护和扩展。通过控制反转，依赖关系的管理被抽象到一个外部容器或框架中，从而降低了代码之间的耦合度。

在Spring框架中，IoC通过依赖注入（Dependency Injection，DI）的方式来实现。DI是一种将一个对象的依赖关系注入到该对象中的技术。通过使用IoC容器，开发者可以声明对象的依赖关系，而IoC容器会在运行时自动将这些依赖关系注入到对象中。这种方式使得对象的创建和依赖关系的配置更加灵活和可维护。

2. 面向切面编程（AOP）：

面向切面编程是一种编程范式，旨在将应用程序中的横切关注点（cross-cutting concerns）从业务逻辑中分离出来。横切关注点是指跨多个模块或组件的通用功能，例如日志记录、事务管理、安全等。在传统的程序设计中，这些横切关注点通常会与业务逻辑混杂在一起，导致代码难以维护和扩展。

AOP通过定义“切面”来将横切关注点从业务逻辑中分离出来。一个切面可以定义为一个跨越多个模块或组件的横切关注点的集合。通过使用AOP，开发者可以将通用功能封装在独立的模块或组件中，并在需要时将其应用于业务逻辑。这种方式可以提高代码的可维护性和可重用性，并减少代码的冗余。

在Spring框架中，AOP通过代理模式来实现。代理模式是一种设计模式，其中客户端通过代理对象来访问目标对象。通过使用代理模式，Spring框架可以在运行时动态地将横切关注点应用到业务逻辑中。

2、Spring框架的优点

1.方便解耦，简化开发，Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理。IOC的作用。

2.AOP编程的支持，Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。（可扩展性）

3.声明式事务的支持，只需要通过配置就可以完成对事务的管理，而无需手动编程。

4.方便程序的测试，Spring对Junit4支持，可以通过注解方便的测试Spring程序。

5.方便集成各种优秀框架，Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts2、Hibernate、MyBatis、Quartz等）的直接支持。

6.降低JavaEE API的使用难度，Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低。

3、IOC程序简单示例

创建Java工程，导入坐标依赖pom.xml

    <dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.2.RELEASE</version></dependency><dependency><groupId>commons-logging</groupId><artifactId>commons-logging</artifactId><version>1.2</version></dependency><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.12</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency></dependencies>

编写接口和实现类，编写具体的实现方法

package com.qcby.service;
public interface UserService {public void hello();
}​package com.qcby.service;
public class UserServiceImpl implements UserService {@Overridepublic void hello() {System.out.println("Hello IOC!!");}
}

编写Spring核心的配置文件，在src目录下创建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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd">​
<!--IOC管理bean--><bean id="userService" class="com.qcby.service.UserServiceImpl" />
</beans>

编写测试方法

package com.qcby.test;
import com.qcby.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Demo {/*** 入门程序*/@Testpublic void run(){// 使用Spring的工厂ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");// 通过工厂获得类:UserService userService = (UserService) applicationContext.getBean("userService");userService.hello();}
}

IOC技术总结

ApplicationContext接口，工厂的接口，使用该接口可以获取到具体的Bean对象。该接口下有两个具体的实现类。

ClassPathXmlApplicationContext，加载类路径下的Spring配置文件。

FileSystemXmlApplicationContext，加载本地磁盘下的Spring配置文件。

4、Spring框架的Bean管理的配置文件方式

id属性，Bean起个名字，在约束中采用ID的约束，唯一，取值要求：必须以字母开始，可以使用字母、数字、连字符、下划线、句话、冒号 id:不能出现特殊字符。

class属性，Bean对象的全路径。

scope属性，scope属性代表Bean的作用范围。 singleton单例（默认值），最常用的方式； prototype多例

​ request应用在Web项目中,每次HTTP请求都会创建一个新的Bean

​ session应用在Web项目中,同一个HTTP Session 共享一个Bean

Bean对象的创建和销毁的两个属性配置

说明：Spring初始化bean或销毁bean时，有时需要作一些处理工作，因此spring可以在创建和拆卸bean的时候调用bean的两个生命周期方法

init-method，当bean被载入到容器的时候调用init-method属性指定的方法

destroy-method，当bean从容器中删除的时候调用destroy-method属性指定的方法

单例的对象销毁：跟着容器工厂关闭才销毁

多例的对象销毁：垃圾回收机制进行回收的

实例化Bean对象的三种方式

①默认是无参数的构造方法（默认方式，基本上使用）

<bean id="us" class="com.qcby.service.UserServiceImpl" />

②静态工厂实例化方式

package com.qcby.demo1;
import com.qcby.service.UserService;
import com.qcby.service.UserServiceImpl;​/*** 静态工厂方式*/
public class StaticFactory {// 静态工厂方式public static UserService createUs(){System.out.println("通过静态工厂的方式创建UserServiceImpl对象...");// 编写很多业务逻辑 权限校验return new UserServiceImpl();}
}<bean id="us" class="com.qcby.demo1.StaticFactory" factory-method="createUs" />

③动态工厂实例化方式

package com.qcby.demo1;
import com.qcby.service.UserService;
import com.qcby.service.UserServiceImpl;
/**** 动态工厂方式**/
public class Dfactory {public UserService createUs(){System.out.println("实例化工厂的方式...");return new UserServiceImpl();}
}<bean id="dfactory" class="com.qcby.demo1.Dfactory" />
<bean id="us" factory-bean="dfactory" factory-method="createUs" />

4、DI依赖注入

IOC和DI的概念

​ IOC：Inverse of Control，控制反转，将对象的创建权反转给Spring

​ DI：Dependency Injection，依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件中

①属性的set方法注入值

编写属性，提供该属性对应的set方法，编写配置文件完成属性值的注入

package com.qcby.service;public class Person {// 编写成员属性，一定需要提供该属性的set方法private String name;private Integer age;private Car car;// 一定需要提供该属性的set方法，IOC容器底层就通过属性的set方法方式注入值public void setName(String name) {this.name = name;}public void setAge(Integer age) {this.age = age;}public void setCar(Car car) {this.car = car;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +", car=" + car +'}';}
}​
package com.qcby.service;
public class Car {// 名称private String cname;// 金额private Double money;public void setCname(String cname) {this.cname = cname;}public void setMoney(Double money) {this.money = money;}@Overridepublic String toString() {return "Car{" +"cname='" + cname + '\'' +", money=" + money +'}';}
}<!--DI：依赖注入-->
<bean id="person" class="com.qcby.service.Person"><property name="car" ref="car" /><property name="name" value="张三" /><property name="age" value="30" />
</bean><bean id="car" class="com.qcby.service.Car"><property name="cname" value="奥迪" /><property name="money" value="300000.00" />
</bean>

②属性构造方法方式注入值

对于类成员变量，构造函数注入。

package com.qcby.domain;
public class Car {// 名称private String cname;// 金额private Double money;public Car(String cname, Double money) {this.cname = cname;this.money = money;}@Overridepublic String toString() {return "Car{" +"cname='" + cname + '\'' +", money=" + money +'}';}
}
​
<bean id="car" class="com.qcby.demo2.Car"><constructor-arg name="cname" value="大奔" /><constructor-arg name="money" value="400000" /></bean>

③数组，集合(List,Set,Map)，Properties等的注入

package com.qcby.domain;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
​
public class CollectionBean {// 数组private String [] strs;public void setStrs(String[] strs) {this.strs = strs;}private List<String> list;public void setList(List<String> list) {this.list = list;}private Map<String,String> map;public void setMap(Map<String, String> map) {this.map = map;}private Properties properties;public void setProperties(Properties properties) {this.properties = properties;}@Overridepublic String toString() {return "CollectionBean{" +"strs=" + Arrays.toString(strs) +", list=" + list +", map=" + map +", properties=" + properties +'}';}
}<!--给集合属性注入值--><bean id="collectionBean" class="com.qcby.demo3.CollectionBean"><property name="strs"><array><value>美美</value><value>小凤</value></array></property><property name="list"><list><value>熊大</value><value>熊二</value></list></property><property name="map"><map><entry key="aaa" value="老王"/><entry key="bbb" value="小王"/></map></property><property name="properties"><props><prop key="username">root</prop><prop key="password">123456</prop></props></property></bean>

5、多配置文件方式

在src的目录下又多创建了一个配置文件，现在是两个核心的配置文件，那么加载这两个配置文件的方式有两种！

主配置文件中包含其他的配置文件:
<import resource="applicationContext2.xml"/>工厂创建的时候直接加载多个配置文件:
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"applicationContext.xml","applicationContext2.xml");

6、Spring框架开发程序的方式

① Spring框架开发方式

1）  需求：编写service和dao的类，演示代码

2） 技术选择：持久层使用原始的JDBC的程序，连接池选择的是Druid连接池。创建maven工程，导入开发的jar包

    <dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.2.RELEASE</version></dependency><dependency><groupId>commons-logging</groupId><artifactId>commons-logging</artifactId><version>1.2</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency><!--连接池--><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.10</version></dependency><!--mysql驱动包--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.6</version></dependency></dependencies>

创建数据库，创建表结构

create database spring_db;
use spring_db;
create table account(id int primary key auto_increment,name varchar(40),money double
)character set utf8 collate utf8_general_ci;
​
insert into account(name,money) values('aaa',1000);
insert into account(name,money) values('bbb',1000);
insert into account(name,money) values('ccc',1000);

编写JavaBean的类

package com.qcby.domain;
import java.io.Serializable;public class Account implements Serializable {private static final long serialVersionUID = 7355810572012650248L;private Integer id;private String name;private Double money;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Double getMoney() {return money;}public void setMoney(Double money) {this.money = money;}​@Overridepublic String toString() {return "Account{" +"id=" + id +", name='" + name + '\'' +", money=" + money +'}';}
}

编写AccountDao的接口和实现类

package com.qcby.dao;
import com.qcby.domain.Account;
import java.util.List;
public interface AccountDao {public List<Account> findAll();
}package com.qcby.dao;
import com.qcby.domain.Account;
import com.alibaba.druid.pool.DruidDataSource;
import javax.sql.DataSource;​
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;public class AccountDaoImpl implements AccountDao {  
//不使用连接池
//1、加载驱动
//2、获取连接
//3、编写sql
//4、预编译sql
//5、设置值
//6、执行sql 拿到结果集
//7、遍历结果集关闭资源
//        String driver = "com.mysql.jdbc.Driver";
//        String url="jdbc:mysql://localhost:3306/spring_db?useUnicode=true&characterEncoding=UTF-8";
//        String user = "root";
//        String password = "123456";
//        String sql = "select * from account";
//        List<Account> res = new ArrayList<Account>();
//        Class.forName(driver);
//        Connection conn = (Connection) DriverManager.getConnection(url, user, password);
//        Statement stmt = (Statement) conn.createStatement();
//        ResultSet rs = (ResultSet) stmt.executeQuery(sql);
//        while(rs.next()){
//            Account acc = new Account();
//            acc.setId(rs.getInt("id")); //获取id字段的值并设置到Account对象中
//            acc.setName(rs.getString("name")); //获取name字段的值并设置到Account对象中
//            acc.setMoney(rs.getDouble("money")); //获取money字段的值并设置到Account对象中
//            res.add(acc);
//        }
//        conn.close();
//        stmt.close();
//        rs.close();
//        return res;// 注入连接池对象private DataSource dataSource;public void setDataSource(DataSource dataSource) {this.dataSource = dataSource;}​/*** 查询所有的数据* @return*/@Overridepublic List<Account> findAll() {/*DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql:///spring_db");dataSource.setUsername("root");dataSource.setPassword("123456");*/List<Account> list = new ArrayList<>();
​       Connection connection = null;PreparedStatement stmt = null;ResultSet rs = null;try {// 获取连接connection = dataSource.getConnection();// 编写sql语句String sql = "select * from account";// 预编译stmt = connection.prepareStatement(sql);// 查询rs = stmt.executeQuery();// 遍历，封装数据while (rs.next()){Account account = new Account();account.setId(rs.getInt("id"));account.setName(rs.getString("name"));account.setMoney(rs.getDouble("money"));list.add(account);}} catch (SQLException e) {e.printStackTrace();}finally {try {connection.close();} catch (SQLException e) {e.printStackTrace();}try {stmt.close();} catch (SQLException e) {e.printStackTrace();}try {rs.close();} catch (SQLException e) {e.printStackTrace();}}return list;} }

package com.qcby.service;
import com.qcby.domain.Account;
import java.util.List;
public interface AccountService {public List<Account> findAll();
}​package com.qcby.service;
import com.qcby.dao.AccountDao;
import com.qcby.domain.Account;
import java.util.List;public class AccountServiceImpl implements AccountService {// 依赖注入private AccountDao accountDao;public void setAccountDao(AccountDao accountDao) {this.accountDao = accountDao;}/*** 查询所有的数据* @return*/@Overridepublic List<Account> findAll() {return accountDao.findAll();}
}

编写配置文件

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--配置连接池--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver" /><property name="url" value="jdbc:mysql:///spring_db" /><property name="username" value="root" /><property name="password" value="123456" /></bean><!--管理bean--><bean id="accountService" class="com.qcby.service.AccountServiceImpl"><property name="accountDao" ref="accountDao" /></bean><bean id="accountDao" class="com.qcby.dao.AccountDaoImpl"><property name="dataSource" ref="dataSource" /></bean>
</beans>

编程测试程序

package com.qcby.test;​
import com.qcby.domain.Account;
import com.qcby.service.AccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;public class Demo1 {@Testpublic void run1(){ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");AccountService accountService = (AccountService) ac.getBean("accountService");// 调用方法List<Account> list = accountService.findAll();for (Account account : list) {System.out.println(account);}}
}

7、IOC注解的方式

① IOC注解方式的简单示例

IOC注解的方式依赖没有变化

编写接口和实现类

package com.qcby.service;public interface UserService {public void hello();​
}package com.qcby.service;
import org.springframework.stereotype.Component;
/*** <bean id="us" class="com.qcby.demo2.UserServiceImpl" />*/
// 组件，作用：把当前类使用IOC容器进行管理，如果没有指定名称，默认使用类名，首字母是小写。userServiceImpl。或者自己指定名称@Component(value = "us")
public class UserServiceImpl implements UserService {
​    @Overridepublic void hello() {System.out.println("Hello IOC注解...");}
}

在需要管理的类上添加@Component注解

@Component(value = "us")
public class UserServiceImpl implements UserService {@Overridepublic void hello() {System.out.println("Hello IOC注解...");}
}

编写配置文件，重点是开启注解扫描。

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--开启注解扫描<context:component-scan base-package="com.qcby.demo2" />--><!--开启注解扫描 com.qcby.所有的包中的所有的类 --><context:component-scan base-package="com.qcby" />
</beans>

编写测试方法

package com.qcby.test;
import com.qcby.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Demo2 {/*** IOC注解方式的入门*/@Testpublic void run1(){// 工厂ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext_anno.xml");// 获取对象UserService userService = (UserService) ac.getBean("us");userService.hello();}
}

② 常用的注解

bean管理类常用的4个注解（作用相同，推荐使用在不同分层上）

​ @Component 普通的类，任何地方

​ @Controller 表现层

​ @Service 业务层

​ @Repository 持久层

依赖注入常用的注解

​ @Value 用于注入普通类型（String，int，double等类型），可以省略

​ @Autowired 默认按类型进行自动装配（引用类型）

​ @Qualifier 和@Autowired一起使用，强制使用名称注入

​ @Resource Java提供的注解，也被支持。使用name属性，按名称注入对象生命周期（作用范围）注解

​ @Scope 生命周期注解，取值singleton（默认值，单实例）和prototype（多例）

初始化方法和销毁方法注解（了解）

​ @PostConstruct 相当于init-method

​ @PreDestroy 相当于destroy-method

单例的销毁时机是跟随容器的 容器销毁对象销毁

多例的销毁时机是java的垃圾回收机制控制的

具体的代码如下

package com.qcby.domain;​
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;​
import javax.annotation.PostConstruct;
import javax.annotation.Resource;// 默认当前类名就是ID名称，首字母小写
@Component(value = "c")
// @Controller
// @Service(value = "c")
// @Repository(value = "c")
// @Scope(value = "singleton")     // 默认值，单例的
// @Scope(value = "prototype")         // 多例的
public class Car {// 注解注入值，属性set方法是可以省略不写的。// 只有一个属性，属性的名称是value，value是可以省略不写的@Value("大奔2")private String cname;@Value(value = "400000")private Double money;// 也不用提供set方法// 按类型自动装配的注解，和id名称没有关系@Autowired// 按id的名称注入，Qualifier不能单独使用，需要Autowired一起使用。// @Qualifier(value = "person")// @Resource Java提供的注解，按名称注入对象，属性名称是name// @Resource(name = "person")private Person person;
​    /*** Car对象创建完成后，调用init方法进行初始化操作*/@PostConstructpublic void init(){System.out.println("操作...");}/*public String getCname() {return cname;}public void setCname(String cname) {this.cname = cname;}
​    public Double getMoney() {return money;}public void setMoney(Double money) {this.money = money;}*/@Overridepublic String toString() {return "Car{" +"cname='" + cname + '\'' +", money=" + money +", person=" + person +'}';}
}​package com.qcby.domain;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
​
@Component(value = "person")
public class Person {
​    @Value("张三")private String pname;@Overridepublic String toString() {return "Person{" +"pname='" + pname + '\'' +'}';}
}package com.qcby.test;
import com.qcby.service.UserService;
import com.qcby.domain.Car;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Demo3 {@Testpublic void run1(){// 工厂ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext_anno.xml");// 获取对象Car car = (Car) ac.getBean("c");System.out.println(car);}
}

③ IOC纯注解的方式

纯注解的方式是微服务架构开发的主要方式，所以也是非常的重要。纯注解的目的是替换掉所有的配置文件。但是需要编写配置类。

编写实体类

package com.qcby.domain;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;@Component
public class Order {
​    @Value("北京")private String address;@Overridepublic String toString() {return "Order{" +"address='" + address + '\'' +'}';}
}

编写配置类，替换掉applicationContext.xml配置文件

package com.qcby.domain;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;/*** Spring的配置类，替换掉applicationContext.xml**/
// 声明当前类是配置类
@Configuration
// 扫描指定的包结构
@ComponentScan(value = "com.qcby")
public class SpringConfig {
}

测试方法的编写

package com.qcby.test;
import com.qcby.domain.Order;
import com.qcby.domain.SpringConfig;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class Demo4 {/*** 编写程序，需要加载配置类*/@Testpublic void run(){// 创建工厂，加载配置类ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);// 获取到对象Order order = (Order) ac.getBean("order");System.out.println(order);}
}

常用的注解总结

@Configuration 声明是配置类

@ComponentScan 扫描具体包结构的

@Import注解 Spring的配置文件可以分成多个配置的，编写多个配置类。用于导入其他配置类

package com.qcby.demo4;
import org.springframework.context.annotation.Configuration;/*** 新的配置类**/
@Configuration      // 声明配置类
public class SpringConfig2 {
}// 声明当前类是配置类
@Configuration
// 扫描指定的包结构
@ComponentScan(value = "com.qcby.demo4")
// @ComponentScan(value = {"com.qcby.demo4","com.qcby.demo3"})
// 引入新的配置类
@Import(value = {SpringConfig2.class})
public class SpringConfig {
}

@Bean注解 只能写在方法上，表明使用此方法创建一个对象，对象创建完成保存到IOC容器中

package com.qcby.demo4;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import javax.sql.DataSource;/**** Spring的配置类，替换掉applicationContext.xml**/
// 声明当前类是配置类
@Configuration
// 扫描指定的包结构
@ComponentScan(value = "com.qcby.demo4")
// @ComponentScan(value = {"com.qcby.demo4","com.qcby.demo3"})
// 引入新的配置类
@Import(value = {SpringConfig2.class})
public class SpringConfig {/*** 创建连接池对象，返回对象，把该方法创建后的对象存入到连接池中，使用@Bean注解解决<!--配置连接池对象--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver" /><property name="url" value="jdbc:mysql:///spring_db" /><property name="username" value="root" /><property name="password" value="123456" /></bean>** @return*/@Bean(name="dataSource")public DataSource createDataSource(){DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql:///spring_db");dataSource.setUsername("root");dataSource.setPassword("123456");return dataSource;}
}​

8、Spring框架整合JUnit单元测试

① Spring框架整合JUnit单元测试

每次进行单元测试的时候，都需要编写创建工厂，加载配置文件等代码，比较繁琐。Spring提供了整合Junit单元测试的技术，可以简化测试开发。

必须先有Junit单元测试的环境，也就是说已经导入Junit单元测试的jar包。咱们已经导入过了。使用的是4.12版本

再导入spring-test的坐标依赖

<dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.0.2.RELEASE</version><scope>test</scope>
</dependency>

编写类和方法，把该类交给IOC容器进行管理

package com.qcby.demo5;public class User {public void sayHello(){System.out.println("Hello....");}
}

编写配置文件applicationContext_test.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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd">​<!--整合单元测试-->
<bean id="user" class="com.qcby.demo5.User"/>​</beans>

编写测试代码

package com.qcby.test;
import com.qcby.demo5.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;/*** Spring整合Junit单元测试**/
@RunWith(value = SpringJUnit4ClassRunner.class)     // 运行单元测试
@ContextConfiguration(value = "classpath:applicationContext_test.xml")   // 加载类路径下的配置文件
public class Demo5 {// 测试哪一个对象，把该对象注入进来，在测试环境下，可以使用注解的方式注入测试的对象// 按类型自动注入@Autowiredprivate User user;@Testpublic void run1(){// 创建工厂，加载配置文件......// 调用对象的方法user.sayHello();}
}

②Spring整合单元测试（纯注解方式）

编写类和方法

package com.qcby.demo6;
import org.springframework.stereotype.Component;​@Component
public class Customer {public void save(){System.out.println("保存客户...");}
}

编写配置类

package com.qcby.demo6;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;/*** Spring整合Junit配置类*/
// 声明
@Configuration
// 扫描包结构
@ComponentScan(value = "com.qcby.demo6")
public class SpringConfig6 {
}

编写测试方法

package com.qcby.test;
import com.qcby.demo6.Customer;
import com.qcby.demo6.SpringConfig6;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;/*** Spring整合Junit 注解的方式测试*/
@RunWith(SpringJUnit4ClassRunner.class)
// 加载配置类
@ContextConfiguration(classes = SpringConfig6.class)
public class Demo6 {
​    // 按类型注入@Autowiredprivate Customer customer;/*** 测试*/@Testpublic void run(){customer.save();}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/441232.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Selenium 隐藏浏览器指纹特征的几种方式

Selenium 隐藏浏览器指纹特征的几种方式

我们使用 Selenium 对网页进行爬虫时&#xff0c;如果不做任何处理直接进行爬取&#xff0c;会导致很多特征是暴露的 对一些做了反爬的网站&#xff0c;做了特征检测&#xff0c;用来阻止一些恶意爬虫 本篇文章将介绍几种常用的隐藏浏览器指纹特征的方式 1. 直接爬取 目标对…
阅读更多...
面试题 02.07. 链表相交（力扣LeetCode）

面试题 02.07. 链表相交（力扣LeetCode）

文章目录 面试题 02.07. 链表相交题目描述解题思路c代码优化后c代码 面试题 02.07. 链表相交 题目描述 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 图示两个链表在节点 c1 …
阅读更多...
shell

shell

目录 一.运行方式 二.编程习惯 三.变量 3.1变量的命名 3.3普通变量(局部变量) 3.4特殊变量 3.5变量子串 3.6变量赋值 四.运算方式 4.1$(( )) 4.2let 4.3expr 4.4bc(小数运算) 4.5$[ ] 4.6awk 4.7总结运算方式 五.条件测试语句 5.1文件 5.2条件测试表达式…
阅读更多...
IDEA：git 回滚本地提交-git 选择 Reset Current Branch to

IDEA：git 回滚本地提交-git 选择 Reset Current Branch to

前言 回滚提交到本地但是还没有 Push 上去的提交 选择我们要回滚的节点&#xff0c;然后点击 git 选择 Reset Current Branch to… 再选择 Hard 。当我们点击 Reset 的时候&#xff0c;代码就会回滚到单前选中的这个版本
阅读更多...
数字时代的工作利器

数字时代的工作利器

当谈到使用工作软件的多样选择时&#xff0c;就像是探索灯塔下的海洋般令人兴奋。无论是新进入办公领域的小白&#xff0c;还是经验丰富的职场老将&#xff0c;我们都渴望找到那些能在工作中为我们点燃生产力和创造力的魔法工具。下面是五款备受欢迎且富有创造力的工作软件推荐…
阅读更多...
专业120+总分400+宁波大学912信号与系统考研经验电子信息通信集成电路光电

专业120+总分400+宁波大学912信号与系统考研经验电子信息通信集成电路光电

今年考研顺利上岸&#xff0c;专业课912信号与系统120&#xff0c;总分400&#xff0c;被宁波大学录取&#xff0c;回望这一年的复习有过迷茫和犹豫&#xff0c;也有过坚持和坚强&#xff0c;总结一下自己的复习得失&#xff0c;希望对大家复习有所帮助。专业课&#xff1a; 前…
阅读更多...
【重磅发布】已开放！模型师入驻、转格式再升级、3D展示框架全新玩法…

【重磅发布】已开放！模型师入驻、转格式再升级、3D展示框架全新玩法…

1月23日&#xff0c;老子云正式发布全新版本。此次新版本包含多板块功能上线和升级&#xff0c;为用户带来了含模型师入驻、三维格式在线转换升级、模型免费增值权益开放、全新3D展示框架等一系列精彩内容&#xff01; 1月23日&#xff0c;老子云正式发布全新版本。此次新版本…
阅读更多...
【vue】图片加载骨架

【vue】图片加载骨架

一、前言 在网速较低或者网站的服务器宽带只有几MB的情况下&#xff0c;网页中的图片加载时&#xff0c;要么空白&#xff0c;要么像打印机一样一行一行地“扫描”出来&#xff0c;为了提升用户体验&#xff0c;可以给图片标签外加一层骨架。 无骨架 有骨架 二、详细设计 每张…
阅读更多...
现在我有三个代码块,分别都调用了同一个接口使用相同的数据,请问怎么精简代码,让他只调用一次接口,将数据存储起来让其他函数共同使用.

现在我有三个代码块,分别都调用了同一个接口使用相同的数据,请问怎么精简代码,让他只调用一次接口,将数据存储起来让其他函数共同使用.

问题描述: 现在我有三个代码块: 一: const getData async () > {console.log(触发了getData接口)let resultData await getActivityInfo(activityId);console.log(resultData,resultData)let id resultData.id;let shareImg resultData.shareImglet shareSubtitle res…
阅读更多...
JWT（JSON Web Token）详解以及在go-zero中配置的方法

JWT（JSON Web Token）详解以及在go-zero中配置的方法

目的 对用户进行身份认证和信息交换 RFC 7519 传统方式 通过session保存对话信息&#xff0c;服务端返回一个session id&#xff0c;用户保存这个id在cookie内&#xff0c;然后每次请求都传给服务端 局限性 对于服务器集群难以向每个服务器共享同一session jwt的方式是…
阅读更多...
备战蓝桥杯---数据结构与STL应用（基础实战篇1）

备战蓝桥杯---数据结构与STL应用（基础实战篇1）

话不多说&#xff0c;直接上题&#xff1a; 当然我们可以用队列&#xff0c;但是其插入复杂度为N,总的复杂度为n^2,肯定会超时&#xff0c;于是我们可以用链表来写&#xff0c;同时把其存在数组中&#xff0c;这样节点的访问复杂度也为o(1).下面是AC代码&#xff1a; 下面我们来…
阅读更多...
学习MySQL仅此一篇就够了（视图）

学习MySQL仅此一篇就够了（视图）

视图 介绍及基本语法 视图&#xff08;View&#xff09;是一种虚拟存在的表。视图中的数据并不在数据库中实际存在&#xff0c;行和列数据来自定义视 图的查询中使用的表&#xff0c;并且是在使用视图时动态生成的。 通俗的讲&#xff0c;视图只保存了查询的SQL逻辑&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023