Hello friend, I'm Ritchie.|
收藏闪存小组博问

Ritchie里其

园龄：2年6个月粉丝：4关注：7

Spring

Spring概念

Spring是一个项目管理框架
官方网站

搭建

引入依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
    </dependencies>

配置文件 applicationConext.xml

<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="userService" class="com.xxx.service.UserService"></bean>
 
</beans>

控制反转

Inversion of Control控制反转，也可以称为依赖倒置，是一种设计思想，将设计好的对象交给容器控制。

新建一个静态工厂类

import com.xxx.entity.Student;
 
public class StudentFactory {
    public static Student getStudent(){
       return  new Student();
    }
}

修改配置文件

<?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="beanFactory" class="com.xxx.utils.BeanFactory" ></bean>-->
    <!--需要工厂类创建对象 由 spring进行管理-->
    <!--
         factory-bean  找到spring容器创建这个对象的工程
         factory-method 创建对象的方法
      -->
<!--    <bean id="student" factory-bean="beanFactory" factory-method="stu"></bean>-->
 
    <bean id="stu" class="com.xxx.utils.StudentFactory" factory-method="getStudent"></bean>
 
 
</beans>

bean的作用范围

singleton：默认值，表示这个 bean 是单例的
prototype：表示这个 bean 是多例的，每次从容器中获取 bean，都会拿到一个全新的 bean

bean生命周期中的两个特殊方法

初始化方法init()：是在构造方法执行后执行。
销毁方法destroy()：销毁对象之前执行。

依赖注入

1.依赖注入Dependency Injection 简称DI和IoC 是一回事。指原来自己创建对象，现在让别人传给你，就相当于注入进来。
2.依赖注入有两种方式 :

A.通过构造方法

<bean id="user" class="com.xxx.entity.User">
        <!--通过构造方法注入值
              name 表示属性名
              value 表示属性值
         -->
        <constructor-arg name="uid" value="10"/>
        <constructor-arg name="uname" value="张三"/>
    </bean>

B.通过set方法

<bean id="u" class="com.xxx.entity.User">
        <property name="uid" value="12"></property>
        <property name="uname" value="您好"></property>
    </bean>

FactoryBean创建复杂对象
1,实现-FactoryBean

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.9.3</version>
        </dependency>
 
    </dependencies>

2,定义一个类 实现 FactoryBean

public class MyFactoryBean implements FactoryBean<Request.Builder> {}

整合JDBC

spring jdbc中的主要类

类与方法 描述
JdbcTemplate spring提供主要操作数据库
update 增 删 改
queryForObject 查询一条记录
query 查询所有

整合数据源 HikariCP

<!-- 比druid更快的数据源 -->
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>4.0.3</version>
        </dependency>

resources -> applicationContext.xml

<!-- 配置数据源 -->
    <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///user?serverTimezone=Asia/Shanghai&amp;characterEncoding=utf8"/>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>
 
    <!-- 配置jdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
 
    <!-- 配置dao -->
    <bean id="userDao" class="com.xxx.dao.impl.UserDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
 
    <!-- 配置service -->
    <bean id="userService" class="com.xxx.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>

UserDaoImpl

@Override
    public User selectById(Integer uId) {
        String sql = "select * from user where uid=?";
        User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), uId);
        return user;
    }

注解配置IOC

注解说明

注解 说明
@Configuration 配置类
@Bean 将对象交给spring容器进行管理
@Qualifier 按照名称来查找spring容器中的对象
@Scope 设置单例多例

1，新建User实体类
2，新建UserConfig类

/*
*  @Configuration 表示是一个配置类
*   相当于编写的applicationContext.xml文件
* */
@Configuration
public class UserConfig {
    /*
    *     @Bean 表示将对象交给spring容器来进行管理， bean 的id 默认是方法名称。可以通过设置注解value的属性值来修改id，比如把"user"改成"u"。
    *     @Scope 设置单例或者多例。
    *
    * */
    @Bean(value = "u")
    @Scope("prototype")
    User user(){
        User user = new User();
        user.setUid(1001);
        user.setUname("张三");
        return  user;
    }
}
@Bean
    Author author1(){
        Author a1= new Author();
        a1.setAid(1002);
        a1.setAname("李四");
        return  a1;
    }
 
@Bean
    Book book(@Qualifier("author1") Author a){
        Book b = new Book();
        b.setBookName("书名");
        b.setAuthor(a);
        return b;
    }

bean实例化注解

注解 作用 说明
@Component 实例化对象 其他层
@Service 实例化对象 业务层
@Repository 实例化对象 持久层
@Controller 实例化对象 表现层对象

存活范围和生命周期

@Component
@Scope("prototype")
Scope的默认值是singleton单例，可以设置多例prototype

依赖注入的注解

注解 说明 位置
@Autowired 先按照类型查找，找到多个再按照名字查找 一般用于私有字段上(spring)
@Qualifier 只能按照指定的名称进行查找 此处和@Autowired配合使用，不能单独使用(spring)
@Resource jdk提供的注解(先按照指定名称查找对象，没有找到，在按照类型查找) 一般用于私有字段上

使用注解完成CRUD（DBUtils）

1，导入依赖
2，数据库配置文件
3，新建实体类User
4，UserDao
5，UserDaoImpl

@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    //需要给一个名称 对应的xml中bean id
    @Qualifier("queryRunner")
    private QueryRunner queryRunner;
    public List<User> selectAllList() {
        List<User> userList = null;
        try {
            String sql="select * from  user";
 
            userList = queryRunner.query(sql, new BeanListHandler<User>(User.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return userList;
    }
}

6，UserService
7，UserServiceImpl

@Service
public class UserServiceImpl implements UserService {
    @Resource
    private UserDaoImpl userDao;
    public List<User> selectAllList() {
        return userDao.selectAllList();
    }
}

8，配置文件

<!--扫描注解包-->
    <context:component-scan base-package="com.qf"/>
    <!--配置数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///user"/>
        <property name="username" value="root"/>
        <property name="password" value="1234"/>
    </bean>
 
    <!--配置QueryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>

9,测试类

public class Test01 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserServiceImpl serviceImpl = applicationContext.getBean("userServiceImpl", UserServiceImpl.class);
        List<User> userList = serviceImpl.selectAllList();
        for (User user :userList){
            System.out.println(user);
        }
    }
}

基于类的Spring配置 纯注解

1，新建注解类

// 配置注解类
@Configuration
// 扫描位置
@ComponentScan(basePackages = "com.xxx")
@PropertySource(value = "classpath:jdbcConfig.properties")
public class UserConfig {
 
    @Value("${jdbc.driver}")
    private  String driver;
    @Value("${jdbc.url}")
    private  String url;
    @Value("${jdbc.username}")
    private  String username;
    @Value("${jdbc.password}")
    private  String password;
 
    @Bean
    public DataSource getDataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
 
    @Bean
    public QueryRunner getQueryRunner(@Qualifier("getDataSource") DataSource dataSource) {
        return new QueryRunner(dataSource);
    }
}

2，jdbcConfig.properties配置文件

@Component

@Component是一个元注解，意思是可以注解其他类注解，如@Controller @Service @Repository @Aspect。
带此注解的类看为组件，当使用基于注解的配置和类路径扫描的时候，这些类就会被实例化。
不指定bean的名称，默认为类名首字母小写。

代理(静态，动态)

静态代理

通过代理类的对象，为原始类的对象（目标类的对象）添加辅助功能，更容易更换代理实现类、利于维护。
代理类数量过多，不利于项目的管理。
多个代理类的辅助功能代码冗余，修改时，维护性差。

代理图示

动态代理

JDK动态代理

官方提供的，可以直接使用，不需要添加依赖。

CGLIB动态代理

无论类是否有接口，都支持通过 CGLIB 创建代理对象。使用时需要添加第三方依赖。

public class Teacher {
    public void showInfo() {
        System.out.println("这是需要被增强的方法");
    }
}
public class MyMethodInterceptor implements MethodInterceptor {
 
    private Object object;
 
    public MyMethodInterceptor(Object obj) {
        this.object = obj;
    }
 
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
 
        System.out.println("前置增强");
        methodProxy.invoke(object, objects);
        System.out.println("后置增强");
        return null;
    }
}
 
public class TestCglib {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
 
        // 创建动态代理增强类，用于创建代理对象
        Enhancer enhancer = new Enhancer();
 
        // 设置被代理对象的类加载器
        enhancer.setClassLoader(teacher.getClass().getClassLoader());
 
        // 设置被代理类
        enhancer.setSuperclass(teacher.getClass());
 
        // 设置方法的拦截
        enhancer.setCallback(new MyMethodInterceptor(teacher));
 
        // 创建代理对象
        Teacher teacher1 = (Teacher) enhancer.create();
        teacher1.showInfo();
    }
}

Spring 中的 AOP 底层就是动态代理：

Spring 中，如果代理的对象有接口，默认使用 JDK 动态代理；如果没有接口，就用 CGLIB 动态代理。
Spring Boot2.0 之后中的 AOP 统一都是 CGLIB 动态代理。

AOP面向切面

（Aspect-Oriented Programming，面向切面编程），以OOP为基础，主要关注的是Aspect方面，方面组件主要用来封装通用的逻辑，可以以低耦合的方式切入到某一批目标对象中。

实现AOP的技术，主要分为两大类：一是采用动态代理技术；二是采用静态织入Weaving的方式，引入特定的语法创建Aspect“方面”。

事务

逻辑上的一组操作，要么都不执行，要么不执行。
是属于MySQL的，不是属于java。
引擎要是InnoDB才支持事务。
事务特性：ACID
原子性（Atomicity）
一致性（Consistency）
隔离性（Isolation）
持久性（Durability）

Spring支持两种方式的事务管理

1，编程式事务管理

1.1 基于TransactionTemplate

A,引入依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

B,新建applicationContext.xml

<!--引入数据库配置信息-->
    <context:property-placeholder location="classpath:jdbcConfig.properties"/>
    <!--配置数据源-->
    <bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
 
    <!--配置jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
 
    <!--配置事务管理器-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
 
    <!--配置事务模板对象-->
    <bean class="org.springframework.transaction.support.TransactionTemplate" id="transactionTemplate">
        <property name="transactionManager" ref="transactionManager"></property>
    </bean>
	<bean class="com.qf.service.AccountService" id="accountService">
 
        <constructor-arg name="jdbcTemplate" ref="jdbcTemplate"></constructor-arg>
        <constructor-arg name="platformTransactionManager" ref="transactionManager"></constructor-arg>
        <constructor-arg name="transactionTemplate" ref="transactionTemplate"></constructor-arg>
    </bean>

C,新建AccountService

public class AccountService {
 
    private PlatformTransactionManager  platformTransactionManager;
 
    private TransactionTemplate  transactionTemplate;
 
    private JdbcTemplate jdbcTemplate;
 
    public AccountService(PlatformTransactionManager platformTransactionManager, TransactionTemplate transactionTemplate, JdbcTemplate jdbcTemplate) {
        this.platformTransactionManager = platformTransactionManager;
        this.transactionTemplate = transactionTemplate;
        this.jdbcTemplate = jdbcTemplate;
    }
 
    public  void  udpate(){
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                try {
                    String sql ="update account set  amoney=? where aname=?";
                    jdbcTemplate.update(sql,8888,"张三");
                    System.out.println(1/0);
                } catch (DataAccessException e) {
                    //表示回滚
               status.setRollbackOnly();
                }
            }
        });
    }
}

1.2 基于TransactionManager
修改Service层代码

public void update02(){
        TransactionStatus transactionStatus =platformTransactionManager.getTransaction(new DefaultTransactionDefinition());
 
        try {
            String sql ="update account set  amoney=? where aname=?";
            jdbcTemplate.update(sql,8888,"李四");
            System.out.println(1/0);
            platformTransactionManager.commit(transactionStatus);
 
        } catch (Exception e) {
            platformTransactionManager.rollback(transactionStatus);
        }
    }

2，声明式事务管理

A.配置数据源
B.配置事务管理器
C.配置切面
D.配置Aop

修改applicationContext.xml

<!--配置切面-->
    <tx:advice id="tvadvice" transaction-manager="transactionManager">
        <tx:attributes>
        <!--
name="find*":匹配切入点方法。可以使用*通配符
read-only="false"：是否是只读事务。默认是false，查询方法建议为true。增删改如果
为只读，则报错。
propagation="REQUIRED"：传播行为。默认REQUIRED（增删改）。查询使用SUPPORTS
timeout="-1":事务超时时间
isolation="DEFAULT"：隔离级别
rollback-for="excep"：如果代码抛出异常，异常名字中含有excep，那么就回滚。一般
不配。
no-rollback-for="excep"：如果代码抛出异常，异常名字中含有excep，那么不回滚。一
般不配。
-->
            <tx:method name="find*"/>
            <tx:method name="update*"/>
            <tx:method name="insert*"/>
        </tx:attributes>
    </tx:advice>
 
    <!--配置aop 事务生效的部分是两个部分的交际-->
    <aop:config>
        <aop:pointcut id="pct" expression="execution(* com.qf.service.AccountService.*(..))"/>
 
        <!--引入切面-->
        <aop:advisor advice-ref="tvadvice" pointcut-ref="pct"/>
    </aop:config>

修改AccountService

public  void  update03(){
        String sql ="update account set  amoney=? where aname=?";
        jdbcTemplate.update(sql,666,"李四");
        System.out.println(1/0);
    }

Spring 并不直接管理事务，而是提供了多种事务管理器 。Spring 事务管理器的接口是： PlatformTransactionManager 。

public interface PlatformTransactionManager {
    //获得事务
    TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;
    //提交事务
    void commit(TransactionStatus var1) throws TransactionException;
    //回滚事务
    void rollback(TransactionStatus var1) throws TransactionException;
}

事务管理器接口 PlatformTransactionManager 通过 getTransaction(TransactionDefinition definition) 方法来得到一个事务，这个方法里面的参数是 TransactionDefinition 类 ，这个类就定义了一些基本的事务属性。

2.1 基于注解的声明式事务

A,添加依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

B,新建applicationContext.xml

<!--引入数据库配置信息-->
    <context:property-placeholder location="classpath:jdbcConfig.properties"/>
    <!--配置数据源-->
    <bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
 
    <!--配置jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
 
    <!--配置事务管理器-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
 
    <!--开启事务注解的支持-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

C,新建AccountService

public interface AccountService {
      void addAccount();
}

D,新建AccountServiceImpl

@Service("accountService")
@Transactional(readOnly = false,propagation = Propagation.REQUIRED)
public class AccountServiceImpl implements AccountService {
    @Resource
    private JdbcTemplate jdbcTemplate;
    public void addAccount() {
        String sql ="update account set amoney=? where aname=?";
        jdbcTemplate.update(sql,2222,"张三");
        System.out.println(1/0);
    }
}

E,新建测试类

public class Test01 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        AccountService accountService = (AccountService) applicationContext.getBean("accountService");
        accountService.addAccount();
    }
}

MyBatis整合Spring

思路

mybatis整合spring

1、单独搭建MyBatis

1.1，引入依赖

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.1</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

1.2，建立mybatis的配置文件

<configuration>
    <typeAliases>
        <package name="com.ujiuye.domain"/>
    </typeAliases>
    <environments default="ee0608">
        <environment id="ee0608">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///table"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="com.ujiuye.mapper"/>
    </mappers>
</configuration>

1.3，建实体类

public class Account implements Serializable {
    private Integer id;
    private String number;
    private Float balance;
}

1.4，新建接口

public interface AccountMapper {
    List<Account> findAllAccounts();
}

1.5，建映射文件

<mapper namespace="com.ujiuye.mapper.AccountMapper">
    <select id="findAllAccounts" resultType="account">
        select * from t_accounts
    </select>
</mapper>

1.6，测试

public class AccountMapperTest {
 
    @Test
    public void findAllAccounts() throws Exception {
        InputStream stream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(stream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        AccountMapper mapper = sqlSession.getMapper(AccountMapper.class);
        List<Account> allAccounts = mapper.findAllAccounts();
        System.out.println(allAccounts);
        sqlSession.close();
    }
}

2、单独搭建Spring

2.1，引入依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.15.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.15.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.15.RELEASE</version>
        </dependency>

2.2，建配置文件

<context:component-scan base-package="com.ujiuye.service.impl"/>

2.3，建接口和实现类

public interface AccountService {
    List<Account> findAllAccounts();
}
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;
    @Test
    public void findAllAccounts() {
        List<Account> allAccounts = accountService.findAllAccounts();
        System.out.println(allAccounts);
    }
}

3、MyBatis整合Spring

3.1，引入依赖

<dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.3</version>
        </dependency>

3.2，修改Spring配置文件

<context:component-scan base-package="com.qf.service.impl"/>
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
 
    <!--接管SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.qf.domain"/>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>
    <!--扫描映射文件-->
    <bean id="scanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.qf.mapper"/>
    </bean>

3.3，mybatis-config.xml中的内容只留下根元素，其他删掉。

3.4，修改业务实现类

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountMapper accountMapper;
 
    public List<Account> findAllAccounts() {
        return accountMapper.findAllAccounts();
    }
}

条件注解

开发，测试，生产环境切换。

1、自定义条件注解

1.1，新建接口

public interface ShowCmd {
    String ShowCmd();
}

1.2，实现类

public class WindowShowCmd implements  ShowCmd {
    public String ShowCmd() {
        return "dir";
    }
}
public class LinuxShowCmd implements  ShowCmd {
    public String ShowCmd() {
        return "ls";
    }
}

1.3，实现Condition接口

public class WindowsConfig implements Condition {
 
   //如果返回值为true 的时候  需要 WindpwConfig  创建 并且放入spring容器进行管理
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String s = context.getEnvironment().getProperty("os.name").toLowerCase();
        System.out.println(s);
        return  s.contains("windows");
    }
}
public class LinuxConfig implements Condition {
    //如果返回值为true 的时候  需要 WindpwConfig  创建 并且放入spring容器进行管理
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String s = context.getEnvironment().getProperty("os.name").toLowerCase();
        System.out.println(s);
        return  s.contains("linux");
    }
}

1.4，测试

public class Test01 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(JavaConfig.class);
        String showCmd = applicationContext.getBean("showCmd", ShowInfoCmd.class).showCmd();
        System.out.println(showCmd);
 
    }
}

2、使用Spring提供的条件注解

2.1，新建实体类

public class DataSource {
    private String url;
    private String username;
    private String password;
 
    public DataSource() {
    }
 
    public DataSource(String url, String username, String password) {
        this.url = url;
        this.username = username;
        this.password = password;
    }
 
    public String getUrl() {
        return url;
    }
 
    public void setUrl(String url) {
        this.url = url;
    }
 
    public String getUsername() {
        return username;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password) {
        this.password = password;
    }
}

2.2，新建配置类

@Configuration
public class JAVAConfig {
 
    @Bean("ds")
    @Profile("test")
    public      DataSource showData(){
        DataSource ds = new DataSource();
        ds.setUrl("jdbc://mysql:3306/test");
        ds.setUsername("root");
        ds.setPassword("root");
        return  ds;
 
    }
 
    @Bean("ds")
    @Profile("dev")
    public      DataSource showD(){
        DataSource ds = new DataSource();
        ds.setUrl("jdbc://mysql:3306/dev");
        ds.setUsername("root");
        ds.setPassword("root");
        return  ds;
 
    }
 
 
}

2.3，测试

public class Test01 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        //设置当前环境
        applicationContext.getEnvironment().setActiveProfiles("dev");
        //注册配置类
        applicationContext.register(JAVAConfig.class);
        //刷新
        applicationContext.refresh();
        DataSource dataSource = applicationContext.getBean(DataSource.class);
        System.out.println(dataSource.getUrl());
    }
}

本文作者：Ritchie里其

本文链接：https://www.cnblogs.com/wang-zeyu/p/16923899.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   Ritchie里其  阅读(31)  评论(0)  编辑  收藏  举报
点击右上角即可分享
微信分享提示
SQL AI 助手
✨欢迎你~🍻
评论
收藏
关注
推荐
深色
回顶
收起
  1. 1 遥か Aimer
遥か - Aimer
00:00 / 00:00
An audio error has occurred.

作词 : aimerrhythm/田中ユウスケ

作曲 : 田中ユウスケ

编曲 : 玉井健二/百田留衣

海岸線の雨に ちらばった君の影

思い出が交差する 海辺の街

君はあの日のまま いまも夢を見てた

君はあの日のまま いまも夢を見てた

遥か記憶の空 2人照らす光

遥か記憶の空 2人照らす光

膝までの浅瀬で 見つけた星

君まで届くなんてさ ありえないような

浅い眠りの中で 深い夢から覚めて

浅い眠りの中で 深い夢から覚めて

裸足のまま駆けてく まばゆい星

君はあの日のまま どんな夢を見てた？

君はあの日のまま どんな夢を見てた？

遥か記憶の空 2人照らす光

遥か記憶の空 2人照らす光

いつまでもこうして 笑っててほしい

夜空に舞い上がる 幾千の花びら

でたらめな誓いで 生きてく日々

君から届くなんてさ ありえないような