Java框架–spring(二、IOC，springBean管理,springJDBC)

一、IOC控制(权)反转

IOC(Inverse of Control),反转控制,是一种设计思想,原来需要在程序中手动地创建对象(在哪需要在哪new),现在我们把创建对象的控制权给spring框架管理

正控:需要对象时,自己手动创建
反控:需要对象时,从spring容器中获取需要的对象

IOC 容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们需要使用的对象都由 ioc 容器进行管理，不需要我们再去手动通过 new 的方式去创建对象，由 ioc 容器直接帮我们组装好，当我们需要使用的时候直接从 ioc 容器中直接获取就可以了。

反转控制权的目的:降低耦合度

底层实现:解析xml / 扫描注解标签 + 工厂模式 + 反射机制

二、spring Bean管理

基于xml配置方式

bean 配置需要 spring 管理的类

<bean id="user" name="user1,user2" scope="prototype" class="com.ffyc.spring.model.User"> </bean>

id:生成的对象标识
class:类的地址(全类名)
name:对象别名(可以有多个)
scope:作用域/范围 scope默认是singleton
- singleton:单例模式,整个应用程序只创建一次,多次获取同一个对象(在spring容器(ClassPathXmlApplicationContext)启动时就创建)
- prototype:原型(多例),每次获取时会创建一个新对象
request:每次 Http 请求都会创建一个 Bean, 仅用于 WebApplicationContext环境
session:同一个 HttpSession 共享一个 Bean, 不同 Session 使用不同的 Bean, 用于 WebApplicationContext环境

xml配置方式依赖注入(DI)

DI：Dependency Injection 依赖注入,在spring创建对象时,将对象的属性(基本类型,引用类型,集合)通过配置**设置给该对象.**实现IOC(控制反转)需要DI(依赖注入)支持

注入方式:

setter方法注入

<property name="name" value="张三"></property>
<property name="age" value="123"></property>

构造方法注入

通过类型注入byType

<constructor-arg type="java.lang.String" value="张三"></constructor-arg>

通过属性名注入byName

<constructor-arg name="name" value="张三"></constructor-arg>

示例:setter注入

给User类加一个集合属性

private List<Integer> list;

public void setList(List<Integer> list) {
	this.list = list;
}

spring配置文件中注入属性值

<!--setter-->
<bean id="user" class="com.ffyc.spring.model.User">
    <property name="name" value="张三"></property>
    <property name="age" value="123"></property>
    <property name="list">
        <list>
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </list>
    </property>
</bean>

测试

package test;

import com.ffyc.spring.model.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("springConfig.xml");
        User user =  (User) app.getBean("user",User.class);
        System.out.println(user);
    }
}

可以看到set方法被调用了,通过set注入,会自动调用实体类的setter方法为属性注入值

基于注解方式

使用注解方式的条件:

使用注解功能需要依赖一个spring aop jar包,注解功能封装在AOP包中

在导入spring核心包springframework时,自动依赖了aop的jar包

开启注解扫描

<?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"       xmlns:aop="http://www.springframework.org/schema/aop"       xsi:schemaLocation="http://www.springframework.org/schema/beans        https://www.springframework.org/schema/beans/spring-beans.xsd        http://www.springframework.org/schema/context        http://www.springframework.org/schema/context/spring-context.xsd        http://www.springframework.org/schema/aop  <!--注解需要aop-->     http://www.springframework.org/schema/aop/spring-aop.xsd">
       
   
       <!--开启spring注解扫描    base-package:扫描指定包下所有类是否有注解标签        --> 
       <context:component-scan base-package="com.ffyc.spring"></context:component-scan>
   
   </beans>

注解方式创建对象

注解方式创建对象(写在类上方)
- @Component(value = “user”) 在model里使用,不写vlaue时,默认当前类名
  
  相当于配置文件中的<bean id="user" class="com.ffyc.spring.model.User"></bean>
```
@Component(value = "user") 
public class User {}

/*//不写value
@Component
public class User {}*/
```
- @Service(value = “userService”)在业务逻辑层中使用(service层)
```
//创建对象
@Service(value = "userService")
public class UserService {}
```
- @Repository(value = “userDao”)在数据访问层(持久层)使用(dao层)
```
@Repository(value = "userDao")//创建对象
public class UserDao {}
```
注解方式指定生成对象单例/多例
- @Scope(value = “singleton”)指定生成对象的策略(singleton-单例 prototype-原型(多例))
```
@Component(value = "user") 
@Scope(value = "singleton")
public class User {}
```

注解方式注入属性

注解方式注入属性(写在属性上方)

@Autowired 自动注入
- 属性required:设置属性取值是否允许null值 required=true/false 默认true
- 可以写在属性上或setter方法上,写在属性上可以不写setter方法
- 注入方式:
  - byType,按属性类型注入,默认使用byType方式
```
	@Autowire
    private UserDao userDao;
    //spring提供的注入方式,Autowired(required = true)默认true 注入的值不能为Null
```
  - byName,按属性名称注入,若想按名称注入,可以结合**@Qualifier**注解一起使用

@Qualifier 自动注入

value=被注解属性的id值(属性为User id=user)

	@Autowired//写在属性上可以不写setter方法
    @Qualifier(value = "userDao")
    private UserDao userDao;

JDK 注解@Resource 自动注入
- Spring 提供了对 jdk 中**@Resource** 注解的支持。
  - @Resource 注解既可以按名称匹配 Bean，也可以按类型匹配 Bean。默认按照 ByName 自动注入
  - 属性name=被注解属性的id值(属性为User id=user)
- ```
@Resource(name="userDao")
private UserDao  userDao;
```

注解方式与XML方式对比

	优点	缺点
注解方式	方便,直观,高效（代码少，没有配置文件的书写那么复杂）	以硬编码的方式写入到 Java 代码中，修改是需要重新编译代码的
xml配置方式	配置和代码是分离的,在 xml 中做修改，无需编译代码，只需重启服务器即可将新的配置加载	编写麻烦，效率低，大型项目过于复杂

三、spring JDBC

Spring 是个一站式框架：

Spring 自身也提供了控制层的 SpringMVC 和 持久层的 Spring JdbcTemplate

spring Jdbc开发步骤

1.下载 Spring JdbcTemplate 的 jar 包,mysql的jar包,阿里druid的jar包

		<!-- spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>
        
        <!-- 阿里数据源 德鲁伊 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

2.导入属性文件(存放jdbc连接的信息)

config.properties文件

# jdbc驱动
driver=com.mysql.cj.jdbc.Driver
# 连接数据库地址
url=jdbc:mysql://127.0.0.1:3306/mybatis_db?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
# 数据库用户名，用于连接数据库
uname=root
# 用户密码（用于连接数据库）
pwd=root
#连接池初始化时初始化的数据库连接数
initialSize=10
#连接池中最多可空闲maxIdle个连接
minIdle=5
#连接池支持的最大连接数
maxActive=20

创建一个存储jdbc连接的配置文件db.xml,导入jdbc属性文件

<?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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">


        <!--配置与数据库连接相关配置-->

    <!--spring读入属性文件-->
    <context:property-placeholder location="config.properties"></context:property-placeholder>
</beans>

3.管理数据源对象

在db.xml中管理与数据库连接(数据源)的配置

	<!--配置druid数据库连接对象                           德鲁伊数据源-->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!--${属性文件中的属性名}-->
        <property name="username" value="${uname}"></property>
        <property name="password" value="${pwd}"></property>
        <property name="url" value="${url}"></property>
        <property name="driverClassName" value="${driver}"></property>
        <property name="initialSize" value="${initialSize}"></property>
        <property name="minIdle" value="${minIdle}"></property>
        <property name="maxActive" value="${maxActive}"></property>
    </bean>

4.在配置文件中创建JdbcTemplate

	<!--spring提供了jdbcTemplate封装类-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="druidDataSource"></property>
    </bean>

配置完JdbcTemplate类后,我们在Java中获取JdbcTemplate的对象,就可以直接使用

JdbcTemplate 中常用的方法

execute() 无返回值，可执行 DDL(create drop alter)，增删改语句
update() 执行新增、修改、删除语句,返回值为影响的行数
queryForObject()返回单个对象
query() 执行查询语句,返回一个List

5.测试JdbcTemplate

UserService类

package com.ffyc.spring.service;

import com.ffyc.spring.dao.UserDao;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;

//创建对象
@Service(value = "userService")
public class UserService {
    
    @Resource(name="userDao")
    private UserDao  userDao;

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

UserDao类

package com.ffyc.spring.dao;

import com.ffyc.spring.model.Admin;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

/*value=别名 Repository仓库*/
@Repository(value = "userDao")//创建对象
public class UserDao {

    @Autowired(required = true)
    JdbcTemplate jdbcTemplate;

    public void test(){
        //execute执行DDL语句(create drop alter)
        //jdbcTemplate.execute("create table test(id int,name varchar(10))");

 		//update 修改,删除,新增
 		//jdbcTemplate.update("insert into admin(account,pass_word,sex)values(?,?,?)","admin888","666666","男");

        
       /* //查询关系中行数
       int count = jdbcTemplate.queryForObject("select count(*) from admin",Integer.class);
        System.out.println(count);//
        */

        //查询绑定变量
       /* String account = jdbcTemplate.queryForObject("select account from admin where id=?", String.class,"1");
        System.out.println(account);*/

        //查找单个对象
        /*
        Admin admin = jdbcTemplate.queryForObject("select * from admin where id=?",
                new Object[]{1},//id=1
                new RowMapper<Admin>(){
                    @Override
                    public Admin mapRow(ResultSet resultSet, int i) throws SQLException {
                        Admin admin1 = new Admin();
                        admin1.setId(resultSet.getInt("id"));
                        admin1.setAccount(resultSet.getString("account"));
                        admin1.setPassWord(resultSet.getString("pass_word"));
                        admin1.setSex(resultSet.getString("sex"));
                        return admin1;
                    }
                });
        System.out.println(admin);*/



        //查找多个对象
        List<Admin> list = jdbcTemplate.query("select * from admin",
                new RowMapper<Admin>() {
                    @Override
                    public Admin mapRow(ResultSet resultSet, int i) throws SQLException {
                        Admin admin1 = new Admin();
                        admin1.setId(resultSet.getInt("id"));
                        admin1.setAccount(resultSet.getString("account"));
                        admin1.setPassWord(resultSet.getString("pass_word"));
                        admin1.setSex(resultSet.getString("sex"));
                        return admin1;
                    }
                });
        System.out.println(list);
    }
}