Spring

轻量级的开源的

Spring 开发步骤

1. 导入坐标
2. 创建Bean
3. 创建application.xml
4. 在配置文件中进行配置
5. 创建ApplicationContext 对象getBean

Bean标签范围配置

scope：值对象的作用范围

1. singleton ：单例的 默认
   1. 当加载配置文件，创建spring容器时候被创建，只会创建一个
2. prototype ：多例的
   1. 当getBean的时候被创建，可以创建多个

3、3 Bean生命周期配置

<bean id="user" class="cn.itcast.dao.userDaoImpl.UserDaoImpl" scope="singleton" init-method="init" destroy-method="destroy">

3、4 Bean实例化三种方法

无参构造方法实例化

工厂静态方法实例化

1. <!--    <bean id="userDao" class="cn.itcast.dao.factory.StaticFactory" factory-method="getUserDao">-->
   

2. 工厂实例方法实例化

 <bean id="factory" class="cn.itcast.dao.factory.DynamicFactory"></bean>
    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>

3、5 Bean依赖注入

概念：Bean的依赖注入是Spring框架核心IOC的具体表现

set注入

userService 中要有userDao的set方法

因为两个都会放到spring容器中

<bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl"></bean>

    <bean id="userService" class="cn.itcast.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>

P命名空间

xmlns:p="http://www.springframework.org/schema/p"

<bean id="userService" class="cn.itcast.service.impl.UserServiceImpl" p:userDao-ref="userDao">

构造器注入

UserServiceImpl

    private UserDao userDao;

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
    public UserServiceImpl(){

    }

applicationContext.xml

  <bean id="userService" class="cn.itcast.service.impl.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>

引入其他配置文件

在applicationContext.xml 主文件中引入其他

<import resource="applicationContext-user.xml"></import>

Spring的重点配置

<bean>标签
	id属性：在容器中Bean的唯一标识符，不允许重复
	class属性：要实例化的Bean的全限定名
	scope属性：Bean的作用范围，常用的是singleton（默认）和prototype
	<property>标签：属性注入
		name属性：属性名称
		value属性：注入的普通属性值
		ref属性：注入的对象引用值
		<list>标签
		<map>标签
		<properties>标签
		<constructor-arg>标签
	<import>标签：导入其他的Spring分文件
		

Spring相关API

applicationContext是一个接口

实现类包括

1. ClassPathXmlApplicationContext：类加载路径 resources下的
2. FileSystemXmlApplicationContext：磁盘路径上加载的文件路径
3. AnnotationConfigApplicationContext：使用注解配置对象的时候，读取注解

Spring配置数据源(连接池)

开发步骤

1. 导包
2. 创建数据源对象
3. 设置数据源的基本连接数据
4. 使用数据源获取连接资源和归还连接资源

Spring 手动创建druid

 DruidDataSource druid = new DruidDataSource();
        //脑子不能抽  username 不能写成name
        druid.setUsername("root");
        druid.setPassword("123456");
        druid.setDriverClassName("com.mysql.jdbc.Driver");
        druid.setUrl("jdbc:mysql://localhost:3306/test?useSSL=false");
        DruidPooledConnection connection = null;
        connection = druid.getConnection();
        System.out.println(connection);

Spring 加载properties文件

要先引入context命名空间的约束路径

命名空间：

xmlns:context="http://www.springframework.org/schema/context"

约束路径

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

解耦

 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="username" value="${user}"></property>
    <property name="password" value="${password}"></property>
    <property name="driverClassName" value="${driverClassName}"></property>
    <property name="url" value="${url}"></property>
</bean>

经过查阅资料，了解是因为spring.xml文件中的这一行出现问题，如果我们使用${username}时，spring默认会优先加载使用系统环境变量，而不是用jdbc.properties配置文件username变量。
在这里我们只需要换个变量名就解决问题了，即吧username换为user就可以了。

Spring注解开发

application.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: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:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="username" value="${user}"></property>
    <property name="password" value="${password}"></property>
    <property name="driverClassName" value="${driverClassName}"></property>
    <property name="url" value="${url}"></property>
</bean>
    <bean id="userDao" class="cn.itcst.dao.impl.UserDaoImpl"></bean>
    <bean id="userService" class="cn.itcst.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
</beans>

原始注解

@Component	@Component	@Component	@Component	@Component	@Component	@Component
@Component	@Component	@Component	@Component	@Component
@Controller	@Controller
@Service
@Repository	@Repository	@Repository	@Repository	@Repository	@Repository	@Repository
@Repository	@Repository	@Repository	@Repository	@Repository	@Repository	@Repository		

1. 主要是代替的配置

   *@Component：使用在类上用于实例化Bean

   *@Controller：使用在web层类上用于实例化Bean

   *@Service：使用在Service层类上用于实例化Bean

   *@Repository：使用在dao层上用于实例化Bean

   *@Autowired：使用在字段上用于根据类型依赖注入

   *@Value：注入普通属性

   *@Scope:作用范围

@Component("userDao")

// <bean id="userDao" class="cn.itcst.dao.impl.UserDaoImpl"></bean>
@Component("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("save running......");
    }
}

/*
    <bean id="userService" class="cn.itcst.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
     </bean>
 */
改为@Service 其实他们三个作用都一样，但是这样可读性高
@Component("userService")
public class UserServiceImpl implements UserService {

//  在userService中注入userDao  <property name="userDao" ref="userDao"></property>
    //自动注入
    @Autowired
    //注入对象id
    @Qualifier("userDao")
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        userDao.save();
    }
}

配置组件扫描

直接用会报错，你要告诉spring你的service在哪里，你配置了你要告诉spring

    <!--配置组件扫描-->
    <!--使用注解开发，要加上组件扫描-->
    <contexe:component-scan base-package="cn.itcast"></contexe:component-scan>

优化

@Autowired：自动填充（通过属性类型去spring中找）

@Qualifier("userDao")：通过id填充

@Resource(name="userDao")：相当于@Autowired+@Qualifier同时使用

作用范围

@Service("userService")
@Scope("prototype")//可以使用@Scope标注这个Bean是单例的还是多例的

@Value("${driverClassName}")  //将jdbc配置文件配置到spring中，可以直接通过el拿到里面的值
//@Value("nbnbnbnb")  没必要这样写
    private String driver;

注解甚至都不用set

初始化方法和销毁方法

在UserService中定义

@PostConstruct：初始化

@PreDestroy：销毁

	@PostConstruct
    public void init(){
        System.out.println("init....");
    }
    @PreDestroy
    public void destory(){
        System.out.println("destory....");
    }

Spring新注解

为什么要新注解：就比如说是别人提供的jar包，字节码文件，你不能去里面加注解，很麻烦，所以不方便
不能全部代替xml

注解 说明

@Configuration 用于指定当前类是一个Spring配置类，当创建容器时会从改类上加载注解

//标志该类是Spring的核心配置文件

@ComponentScan 用于指定Spring在初始化容器要扫描的包

/*
    <!--配置组件扫描-->
    <!--使用注解开发，要加上组件扫描-->
    <contexe:component-scan base-package="cn.itcast"></contexe:component-scan>
 */

@Bean 使用在方法上，标注改方法的返回值存储到Spring容器中

@PropertySource 用于加载properties文件

    <!--加载配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
 */

@Import 用于导入其他配置类

@Import(DataSourceConfiguration.class)

Spring集成Junit的实现

因为测试代码中每次都要重新写

applicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");

UserService userService = context.getBean("userService", UserService.class);

非常繁琐

所以使用springJunit

SpringJunitTest

@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration("classpath:applicationContext.xml")
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {
    @Autowired
    private UserService userService;
    @Autowired
    private DataSource dataSource;
    @Test
    public void test1() throws SQLException {
        userService.save();
        System.out.println(dataSource.getConnection());

    }

UserServiceIml

@Service("userService")
@Scope("prototype")
public class UserServiceImpl implements UserService {
    @Resource(name = "userDao")
    private UserDao userDao;



    @Override
    public void save() {
        userDao.save();
    }
}

UserDao

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("save......");
    }
}

DataSourceConfiguration：分离出来的一个数据源

@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {
    @Value("${user}")
    private String user;
    @Value("${password}")
    private String password;
    @Value("${driverClassName}")
    private String driver;
    @Value("${url}")
    private String url;


    //Spring会将当前方法的返回值，以指定名称存储到Spring容器中
    @Bean("dataSource")
    public DataSource getDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        //脑子不能抽  username 不能写成name
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        return dataSource;
    }

}

SpringConfiguration

@ComponentScan("cn.itcast")
@Import(DataSourceConfiguration.class)
public class SpringConfiguration {

}

Druid:

		<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="username" value="${user}"></property>
            <property name="password" value="${password}"></property>
            <property name="url" value="${url}"></property>
            <property name="driverClassName" value="${driver}"></property>
        </bean>

注意这里是username 和 driverClassName

标签：userDao,Repository,Spring,Component,Bean,public
来源： https://www.cnblogs.com/IsMhhla/p/16200226.html