Spring基础 01

Maven项目的创建

项目所在路径

    - 项目一

        - 创建Module

        - 添加Webapp(Project Structure)

    - 项目二

Spring简介

分层全栈(各层解决方案)轻量级框架，以IoC和AOP为内核

Spring优势

方便解耦，简化开发
AOP编程的支持
声明式事务的支持
方便程序的测试
方便集成各种优秀的框架
降低JavaEE API的使用难度

Spring开发步骤

导入spring坐标

<dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-context</artifactId>

    <version>5.3.20</version>

</dependency>

创建DAO接口

dao.UserDao

package com.miaokela.dao;

public interface UserDao {

    public void save();

}

创建Dao接口实现类

dao.Impl.UserDaoImpl

package com.miaokela.dao.impl;

import com.miaokela.dao.UserDao;

public class UserDaoImpl implements UserDao {

    public void save(){

        System.out.println("save running...");

    }

}

创建Spring配置文件

resources.applicationContext

<?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.miaokela.dao.impl.UserDaoImpl"></bean>

</beans>

从容器中获取实现类对象

demo.UserDaoDemo

package com.miaokela.demo;

import com.miaokela.dao.UserDao;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserDaoDemo {

    public static void main(String[] args) {

        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserDao userDao = (UserDao) app.getBean("userDao");

        userDao.save();

    }

}

Spring配置文件

Bean标签的基本配置

基本属性

默认情况下调用的是类中的无参构造函数

id: 容器唯一标识

class: Bean标签的基本配置全限定名

范围配置

scope 对象作用范围

    - singleton 默认值，单例的

    - prototype 多例的

    - request request域

    - session session域

    - global session 全局session域

Bean创建时间与销毁时间
- singleton
  
  加载配置文件时创建
  
  容器在，对象在
  
  销毁容器时，对象销毁
- prototype
  
  getBean的时候创建
  
  对象一直使用中存在
  
  对象长时间不用，被垃圾回收

Bean的生命周期

init-method

指定类中初始化方法名称
destroy-method

指定类中销毁方法名称

自定义实现方法

package com.miaokela.dao.impl;

import com.miaokela.dao.UserDao;

public class UserDaoImpl implements UserDao {

    public void save() {

        System.out.println("save running...");

    }

    public void init() {

        System.out.println("初始化方法");

    }

    public void destroy() {

        System.out.println("销毁方法");

    }

}

绑定实现方法

<?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.miaokela.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy"></bean>

</beans>

Bean实例化的三种方式
- 无参构造
- 工厂静态方法
  
  需要配置 factory-method
- 工厂实例方法
  
  需要配置 factory-bean、factory-method

依赖注入

通过控制反转，把对象的创建给Spring，降低依赖关系，通过Spring来维护业务层和持久层的依赖关系

业务流程

UserDao -> UserService -> UserController

依赖注入方法

set方法

service.impl.UserServiceImpl

package com.miaokela.service.impl;

import com.miaokela.dao.UserDao;

import com.miaokela.service.UserService;

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {

        this.userDao = userDao;

    }

    public void save() {

//        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

//        UserDao userDao = (UserDao) app.getBean("userDao");

        userDao.save();

    }

}

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.miaokela.dao.impl.UserDaoImpl"></bean>

    <bean id="userService" class="com.miaokela.service.impl.UserServiceImpl">

        <property name="userDao" ref="userDao"></property>

    </bean>

</beans>

demo.UserController

可以使用p命名空间注入

package com.miaokela.demo;

import com.miaokela.service.UserService;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserController {

    public static void main(String[] args) {

        // 调用业务层方法

        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService userService = (UserService) app.getBean("userService");

        userService.save();

    }

}

构造方法

service.impl.UserServiceImpl

package com.miaokela.service.impl;

import com.miaokela.dao.UserDao;

import com.miaokela.service.UserService;

public class UserServiceImpl implements UserService {

    private UserDao userDao;

//    public void setUserDao(UserDao userDao) {

//        this.userDao = userDao;

//    }

    public UserServiceImpl(UserDao userDao) {

        this.userDao = userDao;

    }

    public void save() {

//        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

//        UserDao userDao = (UserDao) app.getBean("userDao");

        userDao.save();

    }

}

applicationContext

<?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.miaokela.dao.impl.UserDaoImpl"></bean>

    <bean id="userService" class="com.miaokela.service.impl.UserServiceImpl">

<!--        <property name="userDao" ref="userDao"></property>-->

        <constructor-arg name="userDao" ref="userDao"></constructor-arg>

    </bean>

</beans>

demo.UserController

package com.miaokela.demo;

import com.miaokela.service.UserService;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserController {

    public static void main(String[] args) {

        // 调用业务层方法

        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService userService = (UserService) app.getBean("userService");

        userService.save();

    }

}

依赖注入的三种数据类型

普通数据类型

applicationContext

<bean id="userService" class="com.miaokela.service.impl.UserServiceImpl">

    <property name="username" value="zhangsan"/></properties>

    <property name="age" value="20"/></properties>

</bean>

引用数据类型

前面的注入方式

集合数据类型

数据模型

public class User {

    private String name;

    private String addr;

    // Getter/Setter

    // toString()

}

实现类

private List<String> strList;

private Map<String, User> userMap;

private Properties properties;

// setter

applicationContext

<bean id="userDao" class="com.miaokela.service.impl.UserDaoImpl">

    <property name="strList"/>

        <list>

            <value>1</value>

            <value>2</value>

            <value>3</value>

        </list>

    </property>

    <property name="strList"/>

        <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</entry>

            <prop key="p2">ppp2</entry>

        </props>

    </property>

</bean>

<bean id="user1" class="com.miaokela.domain.User">

    <property name="name" value="zhangsan"/></properties>

    <property name="addr" value="shanghai"/></properties>

</bean>

<bean id="user2" class="com.miaokela.domain.User">

    <property name="name" value="lisi"/></properties>

    <property name="addr" value="shanghai"/></properties>

</bean>

分模块开发

引入其他配置文件

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

Spring相关Api

ApplicationContext继承体系

FileSystemXmlApplicationContext

ClassPathXmlApplicationContext

AnnotationConfigApplicationContext

getBean()方法的使用

String id的方式

Class<T> requiredType 字节码类型的方式(UserService.class)

Spring配置数据源

连接池的作用

1.提高程序性能

2.实现初始化部分连接资源

3.从数据源中获取连接资源

4.使用后归回连接资源

常见数据源
```
DBCP

C3P0

BoneCP

Druid
```

开发步骤

导入坐标

<dependency>

    <groupId>mysql</groupId>

    <artifactId>mysql-connector-java</artifactId>

    <version>8.0.28</version>

</dependency>

<dependency>

    <groupId>c3p0</groupId>

    <artifactId>c3p0</artifactId>

    <version>0.9.1.2</version>

</dependency>

<dependency>

    <groupId>com.alibaba</groupId>

    <artifactId>druid</artifactId>

    <version>1.2.4</version>

</dependency>

测试数据源

test.java.com.miaokela.DataSourceTest

c3p0

package com.miaokela;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import org.testng.annotations.Test;

import java.beans.PropertyVetoException;

import java.sql.Connection;

import java.sql.SQLException;

public class DataSourceTest {

    @Test

    public void test1() throws PropertyVetoException, SQLException {

        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        dataSource.setDriverClass("com.mysql.jdbc.Driver");

        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");

        dataSource.setUser("root");

        dataSource.setPassword("123456");

        Connection connection = dataSource.getConnection();

        System.out.println(connection);

        connection.close();

    }

}

druid

package com.miaokela;

import com.alibaba.druid.pool.DruidDataSource;

import com.alibaba.druid.pool.DruidPooledConnection;

import org.testng.annotations.Test;

import java.sql.SQLException;

public class DataSourceTest {

    @Test

    public void test2() throws SQLException {

        DruidDataSource dataSource = new DruidDataSource();

        dataSource.setDriverClassName("com.mysql.jdbc.Driver");

        dataSource.setUrl("jdbc:mysql://localhost:3306/test");

        dataSource.setUsername("root");

        dataSource.setPassword("123456");

        DruidPooledConnection connection = dataSource.getConnection();

        System.out.println(connection);

        connection.close();

    }

}

配置数据源文件

resource.jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/test

jdbc.username=root

jdbc.password=123456

读取配置文件连接

package com.miaokela;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import org.testng.annotations.Test;

import java.sql.Connection;

import java.util.ResourceBundle;

public class DataSourceTest {

    @Test

    public void test2() throws Exception {

        // 读取配置文件

        ResourceBundle rb = ResourceBundle.getBundle("jdbc"); // 不需要扩展名

        String driver = rb.getString("jdbc.driver");

        String url = rb.getString("jdbc.url");

        String username = rb.getString("jdbc.username");

        String password = rb.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);

        connection.close();

    }

}

通过Spring配置数据源

将DataSource的创建权由Spring容器去完成

applicationContext

先引入context命名空间，再引入properties

<?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.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>

DataSourceTest

package com.miaokela;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.testng.annotations.Test;

import javax.sql.DataSource;

import java.sql.Connection;

public class DataSourceTest {

    @Test

    public void test1() throws Exception {

        // 从容器对象中导入配置

        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        DataSource dataSource =  app.getBean(DataSource.class);

        Connection connection = dataSource.getConnection();

        System.out.println(connection);

        connection.close();

    }

}

Spring注解开发

原始注解

@Compoment

@Controller

@Service

@Repository

@Autowired

@Qualifier

@Resource

@value

@Scope

@PostContruct

@PreDestroy

注解替代xml的Bean标签

Bean的创建与注入

dao.impl.UserDaoImpl

@Compoment("userDao")

public class UserDaoImpl implements UserDao {

    pubic void save() {

        System.out.println("save running...")

    }

}

dao.service.impl.UserServiceImpl

public class UserServiceImpl implements UserService {

    // @Autowired // 注入 单独使用时，从Spring容器中进行匹配

    // @Qualifier("userDao") // Bean id

    @Resource(name="userDao") // 根据名称注入，相当于Autowired+Qualifier

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {

        this.userDao = userDao;

    }

}

配置组件扫描

<context:compoment-scan base-backage="com.miaokela"/>

衍生注解

Controller  web层

Service     service层

Repository  dao层

普通类型的注入

@Value("${jdbc.driver}")

private String driver

单独设置单例模式

@Service("userService")

@Scope("singleton")

public class UserServiceImpl implements UserService {

    @Value("${jdbc.driver}")

    private String driver;

}

Spring新注解

旧的不能替代xml的注解

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

2.加载properties文件配置 <context:property-placeholder></context:property-placeholder>

3.组件扫描位置 <context:compoment-scan></context:compoment-scan>

4.引入其他文件 <import>

新注解

@Configuration // 配置容器时加载配置

@ComponentScan // Spring初始化容器扫描的包

@Bean // 存储容器

@PropertySource // 加载properties文件

@Import // 导入其他配置

Spring配置

解决不能替代xml注解的问题

config.SpringConfiguration

@Configuration

@ComponentScan("com.miaokela") // 3.组件扫描

@Import({DataSourceConfiguration.class})  // 4.import分模块

public class SpringConfiguration {

}

config.DataSourceConfiguration

@PropertySource("classpath:jdbc.properties") // 2.加载properties文件

public class SpringConfiguration {

    @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("dataSource") // 1.非自定义的Bean Spring会将当前方法的返回值以指定名称存储到Spring容器中

    public DataSource getDataSource() {

        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        dataSource.setDriverClass(driver);

        dataSource.setJdbcUrl(url);

        dataSource.setUser(username);

        dataSource.setPassword(password);

        return dataSource

    }

}

测试

public class DataSourceTest {

    @Test

    public void test1() throws Exception {

        // 从容器对象中导入配置

        ApplicationContext app = new AnnotationConfigApplicationContext("SpringConfiguration.class");

        UserService userService = app.getBean(UserService.class);

        userService.save();

    }

}

Spring整合Junit

让SpringJunit负责创建Spring容器，需要将配置文件名称告诉它

注入需要测试的Bean

步骤

1.导入Spring继承Junit坐标

2.使用@Runwith注解替换原来的运行期

3.使用@ContextConfiguration之顶不过配置文件或配置类

4.使用@Autowire注入需要测试的对象

5.创建测试方法进行测试

导入坐标

<dependency>

    <groupId>junit</groupId>

    <artifactId>junit</artifactId>

    <version>3.8.1</version>

    <scope>test</scope>

</dependency>

<dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-test</artifactId>

    <version>5.3.20</version>

</dependency>

实现整合

需要测试什么直接注入

package com.miaokela;

import com.miaokela.service.UserService;

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;

import javax.activation.DataSource;

@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 Exception {

        userService.save();

        System.out.println(dataSource.getConnection());

    }

}

Spring基础 01 | Ioc的更多相关文章

Spring基础之IOC
一.ioc能解决什么问题 1.Spring是什么 spring是以ioc和aop为核心,能整合第三方框架和类库的企业级应用开源框架. 2.程序的耦合问题例子:Driver类必须存在,编译才通过,Jd ...
01—Spring基础配置IOC
Spring基础——在 IOC 容器中 Bean 之间的关系
一.在 Spring IOC 容器中 Bean 之间存在继承和依赖关系. 需要注意的是,这个继承和依赖指的是 bean 的配置之间的关系,而不是指实际意义上类与类之间的继承与依赖,它们不是一个概念. ...
spring基础-01
IOC : inversion of 缩写, DI:dependency injection 即在调用者中注入被调用者的实例. AOP 面向切面编程,是代理模式的体现.spring默认使用JDK的动态 ...
Java之Spring基础与IoC
Spring About Spring 开源免费框架,轻量级,非入侵式框架.Spring就是一个轻量级的控制反转(IOC)和面向切片编程(AOP)的框架 Maven repo:Spring Web M ...
Spring基础01——在IDEA中编写spring.xml
如果需要在IDEA自动创建spring.xml配置文件,那么我们就需要先引入Spring相关的依赖 <dependency> <groupId>org.springframew ...
spring学习(01)之IOC
spring学习(01)之IOC IOC:控制反转——Spring通过一种称作控制反转(IOC)的技术促进了低耦合.当应用了IOC,一个对象依赖的其它对象会通过被动的方式传递进来,而不是这个对象自己创 ...
Spring笔记：IOC基础
Spring笔记:IOC基础引入IOC 在Java基础中,我们往往使用常见关键字来完成服务对象的创建.举个例子我们有很多U盘,有金士顿的(KingstonUSBDisk)的.闪迪的(SanUSBDi ...
spring基础学习01
spring基础 Spring是一个开放源代码的设计层面框架,他解决的是业务逻辑层和其他各层的松耦合问题,因此它将面向接口的编程思想贯穿整个系统应用 IOC控制反转把创建对象和维护对象之间的关系权利 ...
04 Spring：01.Spring框架简介&&02.程序间耦合&&03.Spring的 IOC 和 DI&&08.面向切面编程 AOP&&10.Spring中事务控制
spring共四天第一天:spring框架的概述以及spring中基于XML的IOC配置第二天:spring中基于注解的IOC和ioc的案例第三天:spring中的aop和基于XML以及注解的A ...

随机推荐

AI五子棋_06 坐标表示到图形表示的算法 Python实现
AI五子棋第六步恭喜你到达第六步! 你已经成功实现了公钥体系最为关键的部分.现在服务器相信你就是你了,下面开始你的战斗. 五子棋的棋盘有15×15个交点,一共有225个交点,我们可以在每一个交点上 ...
Discuz7.2 faq.php页面注入漏洞分析
由于discuz在全局会对GET数组进行addslashes转义,导致该漏洞的产生. 参数问题存在于faq.php的grouppermission函数中. 具体细节访问:网易博客siberia h ...
熟悉使用DOS操作命令
DOS操作实验一.实验目的 DOS是市场上早期获得巨大成功的桌面操作系统,现在很多同学都不太熟悉.本实验的目的就是让同学们读者从操作系统理论的观点来重新认识它们,了解和掌握DOS有关用户接口的特点. ...
厉害了，8.7w人打满分！如果我找 BUG 能像他一样厉害就好了！
你好呀,我是歪歪. 最近在 B 站上看到一个让我觉得"非常哇塞"视频的: https://www.bilibili.com/video/BV1y4421U72G/ 视频的播放量有接 ...
NZOJ 模拟赛5
T1 逃离遗迹根据外星人的回信,在遗迹中有分布着三样道具.当三样道具都拿走后,遗迹就很快自动毁灭,所以必须要在最短时间内离开.遗迹可以看作是由N个房间(编号1..N)和N-1条长度不等通道所组成,并 ...
MySQL创新版9.1.0于2024年10月15日正式发布-新功能特性先睹为快[译]
这个十月发布的版本是MySQL宣布转向新的LTS/Innovation发布模式后的第三个长期支持(LTS)版本和第二个创新(Innovation)版本.更多细节请参见MySQL发布:创新和长期支持.在 ...
小白PDF阅读器重排版时的自动提取背景色功能介绍及实现
小白PDF阅读器在1.35之前的版本对于有深色背景的页面重拍版时并不太完美.对于深色背景区域主要表现在不能分割排版和重排后页面元素割裂感明显.小白PDF阅读器在1.35版本主要针对这两个问题进行了优化 ...
Windows 禁用笔记本键盘
背景笔记本键盘+机械键盘组合如下图: 由此产生一个问题: 笔记本键盘现在的用处是什么? 没什么用,那我们何不把桌面的位置利用起来? 这样怎么样? ===> 为了防止放东西时候误触,我们需要把笔 ...
不会前端也能写官网？没问题，Devbox+Cursor 带你起飞
大家平时都是怎么给自己的产品开发官方网站的? 是不是先在本地配置好环境,然后使用 IDE 写代码,写完代码后部署到服务器生成预览链接,团队协作成员再打开浏览器访问,然后你再修改,再部署,再访问,再修改 ...
【JS篇】控制子集超过一定数量开始轮播
[JS篇]控制子集超过一定数量开始轮播, 这个是很早的时候的一个效果了,经过代码的不断迭代升级修改,现在是最封装的一版本,通过面向对象传参数,适用于任何一个需要放置数量达到一定条件后可执行的函数 / ...

Spring基础 01 | Ioc

Maven项目的创建

Spring简介

Spring优势

Spring开发步骤

Spring配置文件

依赖注入

分模块开发

Spring相关Api

Spring配置数据源

Spring注解开发

Spring基础 01 | Ioc的更多相关文章

随机推荐

热门专题