首页 > 其他分享 >Spring

Spring

时间：2023-07-25 09:47:22浏览次数：20  
标签：jdbc Spring void Bean dataSource public

概念

Spring是什么

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和AOP（Aspect Oriented Programming：面向切面编程）为核心。

提供了表现层 SpringMVC 和持久层 Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

Spring的主要功能

1、作为Spring容器对JavaBean进行管理。

Spring中相关概念

IOC反转控制：把JavaBean对象的创建实例化权交给 Spring负责。

DI依赖注入：依赖注入是Spring框架核心IoC的具体实现，使Spring可以自动为实例化的bean对象进行属性赋值。

MVC：负责将用户输入URL请求和java代码关联

AOP：面向切面设计、解耦、通知回调

JDBC ORM：模板方法模式、建造者模式

JavaBean：实体类

JavaBean的生命周期

实例化对象

通过构造器或工厂方法创建bean实例

对象的赋值

为bean的属性设置值或引用其他bean对象作为属性值

对象的初始化

先调用bean对象的初始化方法

对象的使用

调用对象的方法

对象的销毁

当spring容器关闭时调用bean对象的销毁方法

相关技术实现

实例化对象

JavaBean实例化对象三种方式

JavaBean的无参构造方法实例化

工厂类的静态方法实例化

工厂类的实例方法实例化

对象的赋值

依赖注入的数据类型

普通数据类型：基本数据类型

引用数据类型：将其他bean对象作为该bean对象的属性值

集合数据类型

引用数据类型的注入方式

构造方法

set方法

对象的初始化

在javaBean类中编写init-method方法

对象的使用

调用bean对象的方法

对象的销毁

在javaBean类中编写destroy-method方法

执行流程

基于配置文件开发

创建Dao层接口和实现类

UserDao.java

public interface UserDao {

    public void save();
}

UserDaoImpl.java

import com.example.dao.UserDao;

public class UserDaoImpl implements UserDao {

    public UserDaoImpl(){
        System.out.println("exec Construction  method");
    }

    public void init(){
        System.out.println("exec Init method..");
    }
    @Override
    public void save() {
        System.out.println("userDaoImpl save running...");
    }

    public void destroy(){
        System.out.println("exec Destroy method..");
    }
}

创建Service层接口和实现类

UserService.java

public interface UserService {
    
    public void save();
}

UserServiceImpl.java

import com.example.service.UserService;
import com.example.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        ApplicationContext app = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();
    }
}

创建Spring核心配置文件

命名空间

<?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" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

标签

<bean>标签

bean实例标签：用于配置对象交由Spring 来创建。默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

属性名 作用
id 在Spring容器中Bean实例的唯一标识，不允许重复
class 要实例化的Bean的全限定名
scope Bean的作用范围，常用是Singleton(默认)和prototype，还有request、session、global session
factory-bean 指定工厂类来实例化bean对象
factory-method 指定具体的方法来实例化bean对象

<bean>标签代码实例

<bean id="userService" class="org.example.service.impl.UserServiceImpl" scope="singleton"></bean>
<!--指定工厂类的静态方法来实例化bean对象-->
<bean id="userDao" class="org.example.Factory.StaticFactory" factory-method="createUserDao"></bean>

<!--指定工厂类的实例对象的内部方法来实例化bean对象-->
<bean id="insFactory" class="org.example.Factory.InstanceFactory"></bean>
<bean id="userDao2" factory-bean="insFactory" factory-method="createUserDao"></bean>

scope属性

singleton ：默认值，单例的

prototype ：多例的

request ：WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中

session ：WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中

global session ：WEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于 session

1）当scope的取值为singleton时

Bean的实例化个数：1个

Bean的实例化时机：当Spring核心文件被加载时，实例化Bean对象

Bean的生命周期：

对象创建：当应用加载，创建容器时，对象就被创建了

对象运行：只要容器在，对象一直活着

对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2）当scope的取值为prototype时

Bean的实例化个数：多个

Bean的实例化时机：当调用getBean()方法时实例化Bean对象

对象创建：当使用对象时，创建新的对象实例

对象运行：只要对象在使用中，就一直活着

对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

<property>标签

<bean>标签的子标签，对象属性注入标签。

属性名 作用
name 属性名称
value 注入的普通属性值
ref 注入的对象引用值（需要注入的bean对象的id属性值）

<property>标签代码示例

//注入普通属性值
<bean id="user" class="org.example.User">
    <property name="username" value="caofalin"/>
</bean>

//注入对象属性值
<bean id="userDao" class="org.example.dao.impl.UserDaoImpl">
<bean id="userService" class="org.example.service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"/>
</bean>

<list>标签

<property>标签的子标签，依赖注入数据类型是集合类型之List类型标签

<list>代码示例

//JavaBean
public class UserDaoImpl implements UserDao {

    private List<String> strList;

    public void setStrList(List<String> strList) {
        this.strList = strList;
    }
}
//applicationContext.xml
<bean id="userDao" class="org.example.dao.impl.UserDaoImpl">
    <property name="strList">
        <list>
            <value>aaa</value>
            <value>bbb</value>
            <value>ccc</value>
        </list>
    </property>
</bean>

<map>标签

<property>标签的子标签，依赖注入数据数据是集合类型之Map类型标签

<map>代码示例

//JavaBean
public class UserDaoImpl implements UserDao {

    private Map<String, User> userMap;


    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }
}

//applicationContext.xml
<bean id="user1" class="org.example.domain.User">
    <property name="name" value="tom"/>
</bean>
<bean id="user2" class="org.example.domain.User">
    <property name="name" value="lucy"/>
</bean>
<bean id="userDaoCollection" class="org.example.dao.impl.UserDaoImpl">
    <property name="userMap">
        <map>
            <entry key="u1" value-ref="user1"></entry>
            <entry key="u2" value-ref="user2"></entry>
        </map>
    </property>
</bean>

<properties>标签

<property>标签的子标签，依赖注入数据数据是集合类型之Properties类型标签

<properties>标签代码示例

//JavaBean
public class UserDaoImpl implements UserDao {

    private Properties properties;

    public void setProperties(Properties properties) {
        this.properties = properties;
    }
}
//applicationContext.xml
<bean id="userDao" class="org.example.dao.impl.UserDaoImp">
    <property name="properties">
        <props>
            <prop key="p1">ppp1</prop>
            <prop key="p2">ppp2</prop>
            <prop key="p3">ppp3</prop>
        </props>
    </property>
</bean>

<constructor-arg>标签

<bean>标签的子标签，指定有参构造函数标签

<constructor-arg>代码示例

<bean id="userDao" class="org.example.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="org.example.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

<import>标签

导入其他Spring的子配置文件

<import>代码实例

<import resource="ApplicationContext-Product.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">


    <!--测试运行IoC -->
    <bean id="userDao" class="com.example.dao.impl.UserDaoImpl"></bean>
    <!-- 测试scope -->
<!--    <bean id="userDao1" class="UserDaoImpl" scope="singleton"></bean>-->
<!--    <bean id="userDao2" class="UserDaoImpl" scope="prototype"></bean>-->

    <!-- 测试初始化和销毁方法-->
<!--    <bean id="userDao3" class="UserDaoImpl" init-method="init" destroy-method="destroy"></bean>-->

    <!--Bean实例化：无参构造方法-->
    <bean id="userDao_ByConstructorNoArg" class="com.example.dao.impl.UserDaoImpl"></bean>
    <!--Bean实例化：工厂静态方法-->
    <bean id="userDao_ByStaticFactory" class="com.example.Factory.StaticFactory" factory-method="createUserDao"></bean>

    <!--Bean实例化：工厂实例方法-->
    <bean id="insFactory" class="com.example.Factory.InstanceFactory"></bean>
    <bean id="userDao_ByInstanceFactory" factory-bean="insFactory" factory-method="createUserDao"></bean>


    <!-- 测试依赖注入：set方法 -->
    <bean id="DI_RefData_BySet" class="com.example.service.impl.UserServiceImpl2">
        <!-- name属性是UserServiceImpl2的setUserDao方法名，ref属性是引用id为userDao的bean对象-->
        <property name="userDao" ref="userDao"/>
    </bean>

    <!-- 测试p标签：set方法-->
    <bean id="DI_RefData_ByP_SET" class="com.example.service.impl.UserServiceImpl2" p:userDao-ref="userDao"/>

    <!-- 测试依赖注入：有参构造方法-->
    <bean id="DI_RefData_ByConstructorArg" class="com.example.service.impl.UserServiceImpl3">
        <!-- name属性是UserServiceImpl2的有参构造方法的形参，ref属性是引用id为userDao的bean对象-->
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>


    <!-- 测试依赖注入的数据类型：普通数据类型-->
    <bean id="DI_CommonData_BySet" class="com.example.dao.impl.UserDaoImpl2">
        <property name="name" value="caofalin"></property>
        <property name="age" value="24"></property>
    </bean>

    <!-- 测试依赖注入的数据类型：集合数据类型-->

    <bean id="user1" class="com.example.domain.User">
        <property name="name" value="tom"/>
        <property name="addr" value="beijing"/>
    </bean>
    <bean id="user2" class="com.example.domain.User">
        <property name="name" value="lucy"/>
        <property name="addr" value="tianjin"/>
    </bean>
    <bean id="userDaoCollection" class="com.example.dao.impl.UserDaoImpl3">
        <property name="strList">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>
        <property name="userMap">
            <map>
                <entry key="u1" value-ref="user1"></entry>
                <entry key="u2" value-ref="user2"></entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="p1">ppp1</prop>
                <prop key="p2">ppp2</prop>
                <prop key="p3">ppp3</prop>
            </props>
        </property>
    </bean>


    <bean id="DI_CollectionData_BySet" class="com.example.service.impl.UserServiceImpl2" scope="singleton">
        <!-- name属性是UserServiceImpl2的setUserDao方法名，ref属性是引用id为userDao的bean对象-->
        <property name="userDao" ref="userDaoCollection"/>
    </bean>


    <!-- 测试引用子模块配置文件-->
    <import resource="ApplicationContext-User.xml"/>
    <import resource="ApplicationContext-Product.xml"/>

</beans>

编写Spring测试类

Spring容器的API

ApplicationContext的继承体系

ApplicationContext：接口类型，代表应用上下文，可以通过其实例获得 Spring 容器中的 Bean 对象

ApplicationContext

1）ClassPathXmlApplicationContext

ApplicationContext接口的实现类，从类的根路径下加载配置文件

2）FileSystemXmlApplicationContext

ApplicationContext接口的实现类，从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

3）AnnotationConfigApplicationContext

ApplicationContext接口的实现类，当使用注解配置容器对象时，需要使用此类来创建 spring 容器，用来读取注解。

getBean()

从spring容器中获取bean对象

该方法有两个重载。当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。

当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。

public Object getBean(String name) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name);
}
public <T> T getBean(Class<T> requiredType) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(requiredType);
}

代码示例

//加载Spring核心配置文件
ApplicationContext app = new ClassPathXmlApplicationContext("ApplicationContext.xml");
//获取Spring创建的JavaBean对象
UserDao userDao = (UserDao) app.getBean("userDao_ByConstructorNoArg");
//调用JavaBean对象的方法
userDao.save();

基于注解开发

基础知识

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置

文件可以简化配置，提高开发效率。

Spring注解介绍

原始注解
注解 说明
@Component 使用在类上，用于实例化Bean，当不知道类具体是哪一层时使用
@Controller 使用在web层类上，用于实例化Bean
@Service 使用在service层类上，用于实例化Bean
@Repository 使用在dao层类上，用于实例化Bean
@Autowired 使用在字段上，用于根据类型依赖注入
@Qualifier 使用在字段上，结合@Autowired一起使用用于根据名称进行依赖注入
@Resource 使用在字段上，相当于@Autowired+@Qualifier，按照名称进行注入
@Value 使用在字段上，注入普通属性
@Scope 标注Bean的作用范围
@PostConstruct 使用在方法上，标注该方法是Bean的初始化方法
@PreDestroy 使用在方法上，标注该方法是Bean的销毁方法
代码示例

UserDaoAnnoImpl.java

//@Component("userDaoAnno")
@Repository("userDaoAnno")
public class UserDaoAnnoImpl implements UserDao {

    //注入普通属性
    @Value("${jdbc.driver}")
    private String driver;

    @PostConstruct
    public void init(){
        System.out.println("UserDaoAnno init running...");
    }

    @Override
    public void save() {
        System.out.println("注入的普通属性值是：" + driver);
        System.out.println("UserDaoAnnoImpl save running...");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("UserDaoAnno destroy running...");
    }
}

UserServiceAnnoImpl.java

//@Component("userServiceAnno")
@Service("userServiceAnno")
public class UserServiceAnnoImpl implements UserService {

    //注入bean对象
//    @Autowired
//    @Qualifier("userDaoAnno")
    @Resource(name = "userDaoAnno")
    private UserDao userDao;

    //使用注解注入就可以不写set方法了
//    public void setUserDao(UserDao userDao) {
//        this.userDao = userDao;
//    }

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

以上的这些注解主要是替代Bean 标签的配置，这些注解还不能全部替代xml配置文件，以下部分内容不能被原始注解代替。

  1. 非自定义的Bean的配置：<bean>

  2. 加载properties文件的配置：context:property-placeholder

  3. 组件扫描的配置：context:component-scan

  4. 引入其他文件：<import>

可使用Spring新注解解决上述问题。

注解 说明
@Configuration 使用在Spring配置类上，用于指定当前类是一个Spring配置类，当创建容器时会从该类上加载注解
@ComponentScan 使用在Spring配置类上，用于指定Spring在初始化容器时要扫描的包。
@PropertySource 使用在Spring配置类上，用于加载.properties文件中的配置
@Import 使用在Spring配置类上，用于导入其他配置类
@Bean 使用在方法上，标注将该方法的返回值存储到Spring容器中
代码示例
//SpringConfig.java
@Configuration
@ComponentScan("org.example")
@PropertySource("classpath:jdbc.properties")
@Import({DataSourceConfig.class})
public class SpringConfig {
}

//DataSourceConfig.java
@Configuration
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfig {
    @Value("${jdbc.driver}")
    public String driver;
    @Value("${jdbc.url}")
    public String url;
    @Value("${jdbc.username}")
    public String username;
    @Value("${jdbc.password}")
    public String password;

    @Bean("dataSource")
    public DataSource getDataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return  dataSource;
    }
}

创建Dao层接口和实现类

UserDao.java

package com.example.dao;

public interface UserDao {
    public void save();
}

UserDaoAnnoImpl.java

package com.example.dao.impl;

import com.example.dao.UserDao;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

//@Component("userDaoAnno")
@Repository("userDaoAnno")
public class UserDaoAnnoImpl implements UserDao {

    //注入普通属性
    @Value("${jdbc.driver}")
    private String driver;


    @PostConstruct
    public void init(){
        System.out.println("UserDaoAnno init running...");
    }

    @Override
    public void save() {
        System.out.println("注入的普通属性值是：" + driver);
        System.out.println("UserDaoAnnoImpl save running...");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("UserDaoAnno destroy running...");
    }
}

创建Service层接口和实现类

UserService.java

package com.example.service;

public interface UserService {

    public void save();
}

UserServiceImpl.java

package com.example.service.impl;

import com.example.dao.UserDao;
import com.example.service.UserService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service("userServiceAnno")
public class UserServiceAnnoImpl implements UserService {


    //注入bean对象
//    @Autowired
//    @Qualifier("userDaoAnno")
    @Resource(name = "userDaoAnno")
    private UserDao userDao;

    //使用注解注入就可以不写set方法了
//    public void setUserDao(UserDao userDao) {
//        this.userDao = userDao;
//    }

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

创建Spring配置类

SpringConfig.java

package com.example.config;

import org.springframework.context.annotation.*;

@Configuration
@ComponentScan("com.example")
public class SpringConfig {
}

编写测试类

ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("ApplicationContext-devByAnno.xml");
UserService userService = (UserService) app.getBean("userServiceAnno");
userService.save();

Spring集成Web环境开发

基础知识

传统方式创建Spring容器

Spring容器是通过new ClasspathXmlApplicationContext(spring配置文件) 方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) ，这样的弊端是配置文件加载多次，应用上下文对象创建多次。

集成web环境方式创建Spring容器

Spring通过集成web环境，在启动web时通过监听器来自动加载Spring核心配置文件创建Spring容器。

在Web环境中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

Spring提供了一个监听器ContextLoaderListener，该监听器内部自动加载Spring核心配置文件，创建应用上下文对象，并存储到ServletContext域中，然后使用Spring提供的WebApplicationContextUtils客户端工具来获得Spring容器。

实现步骤

创建web应用项目

选择maven模块，勾选从架构中创建

image-20230208181310117

使用该架构创建的项目默认无java和resources文件夹，需手动创建

image-20230208181656824

创建Dao层接口和实现类

UserDao.java

public interface UserDao {

    public void save();
}

UserDaoImpl.java

import com.example.dao.UserDao;

public class UserDaoImpl implements UserDao {

    public UserDaoImpl(){
        System.out.println("exec Construction  method");
    }

    public void init(){
        System.out.println("exec Init method..");
    }
    @Override
    public void save() {
        System.out.println("userDaoImpl save running...");
    }

    public void destroy(){
        System.out.println("exec Destroy method..");
    }
}

创建Service层接口和实现类

UserService.java

package com.example.service;

public interface UserService {

    public void save();
}

UserServiceImpl.java

package com.example.service.impl;

import com.example.dao.UserDao;
import com.example.service.UserService;

public class UserServiceImpl implements UserService {

    private UserDao userDao;

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

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

创建Spring核心配置文件

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="userDao" class="com.example.dao.impl.UserDaoImpl"></bean>
    <bean id="userService" class="com.example.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
</beans>

创建Servlet类

UserSpringServlet.java

package com.example.web;

import com.example.service.UserService;
import org.springframework.context.ApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class UserSpringServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /**
         * 使用spring提供的web应用上下文工具
         */
        ServletContext servletContext = this.getServletContext();
        ApplicationContext app = org.springframework.web.context.support.WebApplicationContextUtils.getWebApplicationContext(servletContext);
        UserService userService = app.getBean(UserService.class);
        userService.save();

    }
}

配置web.xml文件

web.xml

<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

  <!--配置UserSpringServlet-->
  <servlet>
    <servlet-name>UserSpringServlet</servlet-name>
    <servlet-class>com.example.web.UserSpringServlet</servlet-class>
  </servlet>
  <servlet-mapping>
  <servlet-name>UserSpringServlet</servlet-name>
  <url-pattern>/UserSpringServlet</url-pattern>
  </servlet-mapping>
  
  <!--使用Spring提供的的监听器-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!--全局初始化参数-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:ApplicationContext.xml</param-value>
  </context-param>

</web-app>

客户端测试

Spring配置数据源

基础知识

数据源（连接池）的作用

• 数据源(连接池)是提高程序性能如出现的

• 事先实例化数据源，初始化部分连接资源

• 使用连接资源时从数据源中获取

• 使用完毕后将连接资源归还给数据源

常见的数据源(连接池)：DBCP、C3P0、BoneCP、Druid等

数据源的开发步骤

① 导入数据源的坐标和数据库驱动坐标

② 创建数据源对象

③ 设置数据源的基本连接数据

④ 使用数据源获取连接资源和归还连接资源

手动创建数据源

示例代码

public void test1() throws Exception {
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass("com.mysql.jdbc.Driver");
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
    dataSource.setUser("user123");
    dataSource.setPassword("user123");
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    dataSource.close();
}

手动创建数据源—读取properties文件

示例代码

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=user123
jdbc.password=user123

public void test3() throws PropertyVetoException, SQLException {
    ResourceBundle resourceBundle = ResourceBundle.getBundle("jdbc");
    String driver = resourceBundle.getString("jdbc.driver");
    String url = resourceBundle.getString("jdbc.url");
    String username = resourceBundle.getString("jdbc.username");
    String password = resourceBundle.getString("jdbc.password");

    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass(driver);
    dataSource.setJdbcUrl(url);
    dataSource.setUser(username);
    dataSource.setPassword(password);
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    dataSource.close();
}

Spring创建数据源

示例代码

ApplicationContext-dataSource.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配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
        <property name="user" value="user123"></property>
        <property name="password" value="user123"></property>
    </bean>

</beans>

public void test4() throws SQLException {
    ApplicationContext app = new ClassPathXmlApplicationContext("ApplicationContext-dataSource.xml");
    DataSource dataSource = (DataSource) app.getBean("dataSource");
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}

Spring创建数据源—读取properties文件

配置文件形式

示例代码

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=123456

ApplicationContext-dataSource.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">

    <!--通过Spring读取properties文件方式创建C3P0数据源-->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

</beans>

public void test4() throws SQLException {
    ApplicationContext app = new ClassPathXmlApplicationContext("ApplicationContext-dataSource.xml");
    DataSource dataSource = (DataSource) app.getBean("dataSource");
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}

注解形式

示例代码

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=user123
jdbc.password=user123

DataSourceConfig.java

@Configuration
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfig {
    @Value("${jdbc.driver}")
    public String driver;
    @Value("${jdbc.url}")
    public String url;
    @Value("${jdbc.username}")
    public String username;
    @Value("${jdbc.password}")
    public String password;

    @Bean("dataSource")
    public DataSource getDataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return  dataSource;
    }
}

public void test6() throws SQLException {
    ApplicationContext app = new AnnotationConfigApplicationContext(DataSourceConfig.class);
    DataSource dataSource = (DataSource) app.getBean("dataSource");
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}

Spring整合Junit（待完善）

Spring JDBC Template

tmp

集成Web环境的实现思路（待完善）

配置阶段

配置web.xml DispatcherServlet
设定init-param contextConfigLocaltion = classpath:application.xml
设定url-pattern /*
配置Annotation @Controller @Service @Autowired @RequstMapping…

初始化阶段

调用init()方法 加载配置文件
IoC容器初始化 Map<String,Object>
扫描相关的类 scan-package = “com.***”
创建实例化并保存至容器 通过反射机制将类实例化放入IoC容器中
进行DI操作 扫描IoC容器中的实例，给没有赋值的属性自动赋值
初始化HandlerMapping 将一个URL和一个Method进行一对一的关联映射Map<String,Method>

运行阶段

调用doPost()/doGet() Web容器调用doPost/doGet方法，获得request/response对象
匹配HandlerMapping 从request对象中获得用户输入的url，找到其对应的Method
反射调用method.invoke() 利用反射调用方法并返回结果
response.getWrite().write() 将返回结果输出到浏览器

源码实现大概步骤

  • 初始化配置文件
  • 扫描配置文件中配置的包
  • 实例化IoC容器，将扫描到的类实例化并放入Spring容器中
  • 实现DI依赖注入
  • 实现MVC功能
  • 实现AOP

标签：jdbc,Spring,void,Bean,dataSource,public
From： https://www.cnblogs.com/pacemrc/p/17578187.html

相关文章

  • SpringMVC
    概述SpringMVC是一种基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架，属于SpringFrameWork的后续产品，已经融合在SpringWebFlow中。SpringMVC已经成为目前最主流的MVC框架之一，并且随着Spring3.0的发布，全面超越Struts2，成为最优秀的MVC框架。它通过一套注......
  • 我开源了团队内部基于SpringBoot Web快速开发的API脚手架v1.6.0更新
    什么是rest-api-spring-boot-starterrest-api-spring-boot-starter适用于SpringBootWebAPI快速构建让开发人员快速构建统一规范的业务RestFullAPI不在去关心一些繁琐。重复工作，而是把重点聚焦到业务。动机每次WebAPI常用功能都需要重新写一遍。或者复制之前的项目代码......
  • spring的ModelAndView
    Spring入门19-ModelAndView类别入门19-ModelAndView类别ModelAndView类别就如其名称所示，是代表了MVCWeb程序中Model与View的对象，不过它只是方便您一次返回这两个对象的holder，Model与View两者仍是分离的概念。最简单的ModelAndView是持有View的名称返回，之后View名称......
  • spring的view
    http://book.51cto.com/art/200908/147512.htm24.5.1View实现原理回顾总地来说，当前绝大多数的视图渲染技术都是构建在模板的原理上。我们回想一下，这种基于模板的视图生成方式在我们的生活中到处可见。厨师为了能够提供统一样式的蛋糕，会使用模子来制作，只要提供不同成分的面团，经过......
  • springcloudalibaba 从入门到精通进阶学习路线？深入细化讲解
    springcloudalibaba从入门到精通进阶学习路线？深入细化讲解下面是深入细化的SpringCloudAlibaba学习路线：1.学习SpringBoot和SpringCloud基础知识：在开始学习SpringCloudAlibaba之前，你需要先掌握SpringBoot和SpringCloud的基础知识。学习SpringBoot的核心概念、注解、配......
  • SpringMVC
    SpringMVC什么是MVC模型(dao,service)、视图(jsp)、控制器(servlet)假设：你的项目架构，是设计好的还是演进的？演进的回顾ServletMVVM:MVVMViewModel:双向绑定什么是SpringMVCSpringMVC是SpringFramework的一部分，是基于Java实现MVC的轻量级Web框架官方文档：https:......
  • SpringBoot工程官网创建方式
          ......
  • linux下载安装fastdfs和fastdfs与nginx整合、springboot访问fastdfs
    文章目录需求分析分布式文件系统1FastDFS安装FastDFS和nginx整合2.整合java访问fastdfs服务文件上传查询下载测试整合springboot需求分析搭建fastDFS文件服务器1）安装fastDFStracker和storage2）在storageserver上安装nginx在storageserver上安装nginx的目的是对外通过http访问......
  • 1分布式微服务技术栈-SpringCloud＜Eureka，Ribbon，nacos＞
    微服务技术栈一、微服务介绍了解1架构结构案例与springboot兼容关系拆分案例拆分服务拆分-服务远程调用2eureka注册中心Eureka-提供者与消费者Eureka-eureka原理分析Eureka-搭建eureka服务Eureka-服务注册Eureka-服务发现3Ribbon组件负载均衡Ribbon-负载均衡原理Ribbon-负载......
  • SpringMvc介绍。
    目录1、SpringMvc概述1、基本介绍2、工作流程 3、bean加载控制 二、请求1、请求映射路径2、请求方式3、请求参数4、请求参数（传递json数据）5、日期类型参数传递三、响应四、REST风格1、REST简介2、RESTful入门案例3、RESTful快速开发五、拦截器1、拦截器概念2、拦截器开发3、拦截器......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99