目录
[一 、开发工具安装及配置](#一 、开发工具安装及配置)
[实现:set注入 javaBean对象](#实现:set注入 javaBean对象)
[实现:set注入 基本类型与String](#实现:set注入 基本类型与String)
[实现:set注入 复杂类型](#实现:set注入 复杂类型)
[实现:构造注入 基本类型与String](#实现:构造注入 基本类型与String)
[实现:构造注入 javaBean对象](#实现:构造注入 javaBean对象)
[01. Spring框架的基本理解](#01. Spring框架的基本理解)
[02. Spring框架由哪些模块组成?](#02. Spring框架由哪些模块组成?)
[03. Spring IOC的理解](#03. Spring IOC的理解)
[04. Spring IOC 容器的理解](#04. Spring IOC 容器的理解)
[05. Spring DI 的理解](#05. Spring DI 的理解)
一 、开发工具安装及配置
IDEA简介
IDEA 全称IntelliJ IDEA,是java语⾔开发的集成环境;IntelliJ在业界被公认为最好的java开发⼯具 之⼀,尤其在智能代码助⼿、代码⾃动提示、重构、J2EE⽀持、Ant、JUnit、CVS整合、代码审 查⽅⾯。 JetBrains官⽹ : https://www.jetbrains.com/ 了解:JetBrains公司开发的所有⼯具
安装
1.双击exe⽂件 2.选择安装的⽬录3.选择是否⽣成快捷⽅式和建⽴⽂件关联4.完成安装
配置
设置是否导⼊之前的配置
设置主题
设置需要的功能(定制idea)暂时不选设置插件
选择免费试⽤30天进⼊全局设置
或者进入之后选择 file-》settings
修改⽂件编码区分⼤⼩写代码提示取消设置类模板JDK环境配置
configure->structure for new projects
常⽤快捷键
F7 F8 F9 进方法 往下执行 跳过
快捷键 功能描述 Ctrl+Alt+L 一健格式化代码(和qq冲突,需要关闭qq的热键) Ctrl+shift+R 全局搜索替换 Shift+Shift 强大的搜索功能(无论您想要搜啥都能找到) Ctrl+N 按照类名搜索类 Alt+Insert 可以生成构造器/Getter/Setter等 Alt+Enter 导入包 Ctrl+Alt+T 可以把代码包在一个块内,例如:try/catch Ctrl+R 替换文本 Ctrl+F 查找文本 Ctrl+O 重写方法 Shift+F6 重构-重命名 Ctrl+X 删除行 Ctrl+D 复制行 Ctrl+Y 删除行 Ctrl+/ 单行注释 Ctrl+Shift+/ 多行注释 Ctrl+H 显示类结构图(类的继承层次) Ctrl+Alt+B 跳转到方法实现处 Alt+Left/Right 切换代码视图 Alt+Up/Down 在方法间快速移动定位 iter 生成array for代码块 itli 生成List的遍历 iter 生成增强for循环 psvm main函数 sout System.out.println() Ctrl+J 查看更多
部署maven
1.配置环境
或者
进行以下更改
2.创建一个maven项目
选择maven
在poi.xml配置依赖
二、初始Spring
Spring****历史由来
企业级应用指的是 大规模、性能和安全要求高、业务复杂、灵活多变的大型 WEB 应用程序。
- **大规模:**用户量和 IP/PV访问量大、海量数据、功能模块多代码量大。
- **业务复杂:**涉及金融、期货、电信等特殊领域的业务逻辑复杂,对系统架构提出新要求。
- **性能和安全要求高:**响应毫秒数和安全级别均有很高的要求。
- **灵活多变:**经常性的业务变更,也对开发效率以及项目部署等工作有更高的要求。
重量级技术向轻量级开发过度
为了实现企业级应用开发各类需求,涌现出以EJB为代表的一系列技术。
Spring之父
Rod Johnson,SpringFramework创始人, interface21 CEO。
• 1996 年开始关注 Java 服务器端技术
• Servlet2.4 和 JDO2.0 专家组成员
• Expert One-to-One J2EE Design and Development(2002)
• 阐述了 J2EE 使用EJB 开发设计的优点及解决方案
• Expert One-to-One J2EE Development without EJB(2004)
• 阐述了 J2EE 开发不使用 EJB的解决方式(Spring 雏形 )
• 2004年3月24日发布了Spring Framework 1.0 final
**技术主张:**技术应当回归实用为主,简化 Java 开发
**Spring的理论基础:**Spring 框架建立在本书中对于J2EE企业级应用的开发与设计的核心理念之上,追求简洁、轻量级的开发方式,让系统具备更好的健壮性和可扩展性。
Spring****体系结构
- **Spring Core:**Spring框架的最基础部分,提供DI(依赖注入)特性。
- **Spring Context:**Spring上下文,提供Bean容器的集合。
- **Spring AOP:**基于Spring Core的符合规范的切面编程的实现。
- **Spring JDBC:**提供了JDBC的抽象层,简化了JDBC编码。
- **Spring ORM:**对主流ORM框架(Hibernate、Toplink等)进行集成。
- **Spring Web:**为Spring在Web应用程序中的使用提供了支持。
Spring 官网 spring.io
Spring****生态系统
- **Spring Boot:**简化产品级的 Spring 应用和服务的创建,简化了配置文件,使用嵌入式web服务器,含有诸多开箱即用微服务功能。
- **Spring Data:**是一个数据访问及操作的工具包,封装了很多种数据及数据库的访问相关技术,包括:jdbc、Redis、MongoDB、Neo4j等。
- **Spring AMQP:**消息队列操作的工具包,主要是封装了RabbitMQ的操作。
- **Spring Cloud:**微服务工具包,用于创建基于云计算架构的原生微服务应用。
- **Spring Security:**是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。
- **Spring Mobile:**是Spring MVC的扩展,用来简化手机上的Web应用开发。
三、解耦实现
=======================spring==============================
spring两大核心思想:
- 一.springIOC(控制反转)springDI(依赖注入)
- 二.springAOP(面向切面)
springIOC:springIOC容器扮演项目的载体,管理整个Java项目,ioc容器可以是项目更符合高内聚,低耦合的变成思想,"解耦"
耦合:类与类有耦合,方法与方法有耦合解耦:
- 1.尽量避免new对象,通过反射实例化
- 2.需要创建的对象不要写死,而是把类名保存在独立的properties文件中,按需加载
jdbc
java/** * @author zkt * @Version 1.0 * @since 2024/7/15 */ public class Test01 { public static void main(String[] args) throws Exception{ /************************方式1(耦合度高)****************************/ // DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver()); // Connection root = DriverManager.getConnection("jdbc:mysql://localhost:3306/myhomework04?serverTimezone=GMT", "root", "123456"); // System.out.println(root);//com.mysql.cj.jdbc.ConnectionImpl@ba8d91c /************************方式2(耦合度中)****************************/ // Class.forName("com.mysql.cj.jdbc.Driver"); // Connection root = DriverManager.getConnection("jdbc:mysql://localhost:3306/myhomework04?serverTimezone=GMT", "root", "123456"); // System.out.println(root);//com.mysql.cj.jdbc.ConnectionImpl@70b0b186 /************************方式3(耦合度低)****************************/ //1.创建工具 Properties properties = new Properties(); //2.加载资源文件 InputStream stream = Test01.class.getClassLoader().getResourceAsStream("jdbc.properties"); properties.load(stream); //3.通过key获取value String driver = properties.getProperty("msg1"); String url = properties.getProperty("msg2"); String user = properties.getProperty("msg3"); String pwd = properties.getProperty("msg4"); Class.forName(driver); Connection root = DriverManager.getConnection(url,user,pwd); System.out.println(root);//com.mysql.cj.jdbc.ConnectionImpl@ba8d91c } }
三层思想
首先需要在main-》resources下新建一个properties配置文件
service=com.zkt.service.UserServiceImp dao=com.zkt.dao.UserDaoImp
controller
javapublic interface IUserController { public void save(); } public class UserControllerImp implements IUserController { /******************高耦合**********************/ // IUserService service = new UserServiceImp(); /****************高耦低**********************/ IUserService service = (IUserService) BeansFactory.getBean("service"); public void save() { System.out.println("====controller的新增===="); service.save(); } }
dao
javapublic interface IUserDao { public void save(); } public class UserDaoImp implements IUserDao{ public void save() { System.out.println("====dao的新增===="); } }
service
javapublic interface IUserService { public void save(); } public class UserServiceImp implements IUserService { /******************高耦合**********************/ // IUserDao dao = new UserDaoImp(); /****************高耦低**********************/ IUserDao dao = (IUserDao) BeansFactory.getBean("dao"); public void save() { System.out.println("====service的新增===="); dao.save(); } }
factory
javapublic class BeansFactory { public static Object getBean(String key){ //按照需求创建对象 try { //准备工作 Properties properties = new Properties(); InputStream stream = BeansFactory.class.getClassLoader().getResourceAsStream("beans.propreties"); properties.load(stream); //获取vlaue创建对象 String pathClass = properties.getProperty(key); return Class.forName(pathClass).newInstance(); } catch (IOException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } return null; } }
test
java/** * @author zkt * @Version 1.0 * @since 2024/7/15 */ public class Test01 { public static void main(String[] args) { IUserController controller = new UserControllerImp(); controller.save(); } }
四、SpringIOC
======================springIOC/DI=========================
spring环境搭建:1.坐标
2.配置文件
springIOC:控制反转
- ● 关键字:IOC名词解释,作用是解耦,使用IOC容器管理项目组件之间的耦合关系
- **● IOC( Inversion of Control,中文释义:控制反转 )**是Spring框架的核心思想之一,主要用于解耦。IOC是指将创建对象的控制权转移给Spring框架进行管理。 由Spring框架根据配置文件或注解等方式,创建bean对象并管理各个bean对象之间的依赖关系。使对象之间形成松散耦合的关系,实现解耦;
○ 控制 :指的是对象创建(实例化、管理)的权力
○ 反转 :控制权交给外部环境(Spring框架、IoC容器)
springIOC使用步骤:
1.创建类
2.将需要spring管理的类,注入springIOC容器
XML<bean id="唯一标识" class="类的完全限定名称"></bean>
3.以解耦方式获取javaBean实例对象
3.1加载spring主配置文件,获取spring核心对象
javaApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
3.2获取javaBean
javaStudent student = (Student) applicationContext.getBean("student");
实现:
在poi.xml配置
XML<dependencies> <!-- spring --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.12</version> </dependency> </dependencies>
新建类
controller
javapublic interface IUserController { public void save(); } public class UserControllerImp implements IUserController{ public void save() { System.out.println("====controller的新增===="); } }
dao
javapublic interface IUserDao { public void save(); } public class UserDaoImp implements IUserDao{ public void save() { System.out.println("====dao的新增===="); } }
service
javapublic interface IUserService { public void save(); } public class UserServiceImp implements IUserService{ public void save() { System.out.println("====service的新增===="); } }
pojo
javapublic class Student { private String stuName; private String stuHobby; private int stuAge; get、set 构造方法 tostring 省略 }
2.将需要spring管理的类,注入springIOC容器
main-》resources下 new -》xml->SpringConfig
beans.xml
XML<!-- 注入studdent类 --> <bean id="student" class="com.zkt.pojo.Student"></bean> <!-- 注入date --> <bean id="date" class="java.util.Date"/> <!-- 注入dao --> <bean id="daoImp" class="com.zkt.dao.UserDaoImp"/> <!-- 注入service --> <bean id="serviceImp" class="com.zkt.service.UserServiceImp"/> <!-- 注入controller --> <bean id="controllerImp" class="com.zkt.controller.UserControllerImp"/>
3.以解耦方式获取javaBean实例对象
test
java/** * @author zkt * @Version 1.0 * @since 2024/7/15 */ public class Test01 { public static void main(String[] args) { //1.加载spring主配置文件,获取spring核心对象 ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml"); //2.获取javaBean Student student = (Student)applicationContext.getBean("student"); Date date = (Date)applicationContext.getBean("date"); System.out.println(date); System.out.println(student); System.out.println("======================================="); IUserDao dao = (IUserDao)applicationContext.getBean("daoImp"); IUserService service = (IUserService)applicationContext.getBean("serviceImp"); IUserController controller = (IUserController)applicationContext.getBean("controllerImp"); controller.save(); service.save(); dao.save(); } }
Demo02 Demo03BeansFactory ApplicationContext
getBean(key) getBean(id)
beans.properties beans.xml
key=value id=class
关键字:
接口
BeanFactory(父):多例模式
ApplicationContext(子):单例模式
实现类
ClassPathXmlApplicationContext:通过相对路径加载主配置文件
FileSystemXmlApplicationContext:通过绝对路径加载主配置文件
AnnotationConfigApplicationContext:加载配置"类"
五、SpringDI
======================springIOC/DI=========================
Spring DI 的理解DI(Dependecy Inject,中文释义:依赖注入)
是对IOC概念的不同角度的描述,是指应用程序在运行时,每一个bean对象都依赖IOC容器注入当前bean对象所需要的另外一个bean对象。(例如在MyBatis整合Spring时,SqlSessionFactoryBean 依赖IOC容器注入一个
DataSource数据源bean);
springDI实现方式:
- 1.set注入
- 2.构造注入
- 3.注解注入
springDI支持的数据类型:
- 1.基本类型与String
- 2.javaBean对象
- 3.复杂类型**(构造注入不支持)**
di实现步骤(set)****:
- 1.思考
- 2.提供对应方法(set)
setXXXX()
- 3.配置
XML<property 属性名="属性值"></property> 属性: name:属性名 ref:注入的值的引用 value:注入的值
di实现步骤(构造)
- 1.思考
- 2.提供对应方法(构造)
- 3.配置
XML<constructor-arg 属性名="属性值"></constructor-arg> 属性: name:属性名 type: 参数类型 index: 参数下标 ref:注入的值的引用 value:注入的值
总结IOC-DI:
原来要对象,自己造自己用
现在要对象,容器造,容器拼一起,自己用
spring胶水框架
set注入
**实现:**set注入 javaBean对象
在poi.xml配置
XML<dependencies> <!-- spring --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.12</version> </dependency> </dependencies>
新建类
将需要spring管理的类,注入springIOC容器
main-》resources下 new -》xml->SpringConfig
beans.xml
XML<!-- 注入dao --> <bean id="daoImp" class="com.zkt.dao.UserDaoImp"/> <!-- 注入service --> <bean id="serviceImp" class="com.zkt.service.UserServiceImp"> <property name="dao" ref="daoImp"/> </bean> <!-- 注入controller --> <bean id="controllerImp" class="com.zkt.controller.UserControllerImp"> <property name="service" ref="serviceImp"/> </bean>
controller
javapublic interface IUserController { public void save(); } public class UserControllerImp implements IUserController{ IUserService service; public void setService(IUserService service) { this.service = service; } public void save() { System.out.println("====controller的新增===="); service.save(); } }
dao
javapublic interface IUserDao { public void save(); } public class UserDaoImp implements IUserDao{ public void save() { System.out.println("====dao的新增===="); } }
service
javapublic interface IUserService { public void save(); } public class UserServiceImp implements IUserService{ IUserDao dao; public void setDao(IUserDao dao) { this.dao = dao; } public void save() { System.out.println("====service的新增===="); dao.save(); } }
test
java** * @author zkt * @Version 1.0 * @since 2024/7/15 */ public class Test01 { public static void main(String[] args) { //1.加载spring主配置文件,获取spring核心对象 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml"); //2.获取javaBean IUserController controller = (IUserController) applicationContext.getBean("controllerImp"); controller.save(); } }
**实现:**set注入 基本类型与String
配置同上
pojo
Student
javapublic class Student { private String stuName; private String stuHobby; private int stuAge; set tostring 省略 }
beans.xml
XML<!-- =========================set注入基本类型与String============================== --> <bean id="student" class="com.zkt.pojo.Student"> <property name="stuName" value="zkt"></property> <property name="stuAge" value="22"></property> <property name="stuHobby" value="足球"></property> </bean>
**实现:**set注入 复杂类型
配置同上
pojo
Teacher
javapublic class Teacher { private List mylist; private Set myset; private String[] myarray; private Map mymap; private Properties prop; set tostring 省略 }
beans.xml
XML<bean id="teacher" class="com.zkt.pojo.Teacher"> <property name="mymap"> <map> <entry key="zkt1" value="football"></entry> <entry key="zkt2" value="pingpang"></entry> <entry key="zkt3" value="basketball"></entry> </map> </property> <property name="prop"> <props> <prop key="中国">北京</prop> <prop key="法国">巴黎</prop> <prop key="葡萄牙">里斯本</prop> </props> </property> <property name="myarray"> <array> <value>小米</value> <value>华为</value> <value>苹果</value> </array> </property> <property name="mylist"> <list> <value>石家包子</value> <value>老孙家泡馍</value> <value>马昆砂锅</value> <value>新亮烤肉</value> </list> </property> <property name="myset"> <set> <value>cs2</value> <value>lol</value> <value>apex</value> </set> </property> </bean>
测试:
javapublic class Test01 { public static void main(String[] args) { //1.加载spring主配置文件,获取spring核心对象 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml"); //2.获取javaBean // IUserController controller = (IUserController) applicationContext.getBean("controllerImp"); // controller.save(); Student student = (Student)applicationContext.getBean("student"); System.out.println(student); Teacher teacher = (Teacher)applicationContext.getBean("teacher"); System.out.println(teacher); } }
构造注入
**实现:**构造注入 基本类型与String
pojo
Student
javapublic class Student { private String stuName; private String stuHobby; private int stuAge; 构造方法 无参 有参 tostring 省略 }
beans.xml
XML<!-- =========================构造注入基本类型与String============================== --> <bean id="student2" class="com.zkt.pojo.Student"> <constructor-arg name="stuName" value="zkt1"></constructor-arg> <constructor-arg name="stuHobby" value="football"></constructor-arg> <constructor-arg name="stuAge" value="22"></constructor-arg> </bean> <bean id="student3" class="com.zkt.pojo.Student"> <constructor-arg index="0" value="zkt2"></constructor-arg> <constructor-arg index="1" value="basketball"></constructor-arg> <constructor-arg index="2" value="22"></constructor-arg> </bean> <bean id="student4" class="com.zkt.pojo.Student"> <constructor-arg type="java.lang.String" value="zkt3"></constructor-arg> <constructor-arg type="java.lang.String" value="run"></constructor-arg> <constructor-arg type="int" value="24"></constructor-arg> </bean>
测试:
javapublic class Test01 { public static void main(String[] args) { //1.加载spring主配置文件,获取spring核心对象 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml"); Student student2 = (Student) applicationContext.getBean("student2"); Student student3 = (Student) applicationContext.getBean("student3"); Student student4 = (Student) applicationContext.getBean("student4"); System.out.println(student2); System.out.println(student3); System.out.println(student4); } }
**实现:**构造注入 javaBean对象
pojo
Teacher
javapublic class Teacher { private List mylist; private Set myset; private String[] myarray; private Map mymap; private Properties prop; private Student student; public Teacher(Student student) { this.student = student; } public Teacher() { } tostring 省略 }
beans.xml
XML<!-- =========================构造注入javaBean对象============================== --> <bean id="student5" class="com.zkt.pojo.Student"/> <bean id="teacher2" class="com.zkt.pojo.Teacher"> <constructor-arg name="student" ref="student5"></constructor-arg> </bean>
测试
javapublic class Test01 { public static void main(String[] args) { //1.加载spring主配置文件,获取spring核心对象 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml"); Teacher teacher2 = (Teacher) applicationContext.getBean("teacher2"); System.out.println(teacher2); } }
六、Spring常见面试题
01. Spring框架的基本理解
关键词:核心思想IOC\AOP、作用(解耦、简化)、简单描述框架组成
Spring框架是一款轻量级的开发框架,核心思想是IOC(控制反转)和AOP(面向切面编程),为Java应用程序开发提供组件管理服务,用于组件之间的解耦,以及简化第三方JavaEE中间件技术的使用(JMS、任务调度、缓存、ORM框架),是一个基础架构型的开发框架。
Spring框架包括:IOC容器、Validation数据校验、AOP面向切面编程、Transactions事务管理、Spring JDBC、Spring MVC框架、以及各类第三方JavaEE中间件技术集成;
02. Spring框架由哪些模块组成?
关键词:官方文档描述,由7个模块组成
根据官方文档的描述,主要包括以下常用5个模块:
Core: 核心模块
包括:IoC Container (ioc容器),Events (事件通知机制),Resources (资源加载机制),i18n (国际化),Validation (数据校验),Data Binding (数据绑定),Type Conversion (类型转换),SpEL (Spring表达式),AOP (面向切面编程);
Testing: 测试模块
包括:Mock Objects (测试模拟对象),TestContext Framework (测试框架),Spring MVC Test (用于测试Spring MVC),WebTestClient (用于测试WebClient、Restful、WebFlux 等);
Data Access: 数据访问模块
包括:Transactions (事务管理),DAO Support (统一的数据访问对象 DAO 模式的封装),JDBC (Spring对于JDBC的操作封装),ORM (Spring 对于对象关系映射框架的封装,例如Hibernate 等框架)等;
Web Servlet: 基于Servlet的Web应用开发
包括:Spring MVC (Spring基于MVC模式设计封装的Web框架),WebSocket (Spring 集成 WebSocket,WebSocket 是一个服务器与客户端双向通信的技术)等;
Integration: 企业级系统集成模块(不同系统之间的交互集成)
包括:Remoting (Spring 用于在分布式系统中进行远程服务调用的通讯框架),JMS (Spring集成各类Java消息中间件、Java消息服务【Java Message Service】,例如ActiveMQ等),Java Email (邮件发送),Tasks Scheduling (任务调度);
03. Spring IOC的理解
关键词:IOC 名词解释,作用是解耦,使用 IOC 容器管理项目组件之间的耦合关系
IOC (Inversion of Control, 中文释义: 控制反转) 是 Spring 框架的核心思想之一,主要用于了解耦。IOC 是指将创建对象的控制权转移给 Spring 框架进行管理。由 Spring 框架根据配置文件或注解等方式,创建 bean 对象并管理各个 bean 对象之间的依赖关系。使对象之间形成松散耦合的关系,实现解耦
- 控制:指的是对对象创建(实例化、管理)的权力
- 反转:控制权交给外部环境(Spring 框架、Ioc 容器)
04. Spring IOC 容器的理解
- 关键词:IOC 容器的作用、存储形式、初始化过程
- IOC通常被理解为 Ioc Container 容器,IOC 容器其实就是一个 Map,key 是每个bean 对象的ID,value 是 bean 对象本身。IOC 容器负责创建 bean 对象并管理 bean 的生命周期,并且根据配置好配置文件或注解,管理 Ioc 容器中的每个 bean,以及根据 bean 之间的依赖关系,完成 bean 之间的注入。
- IOC 容器属于 Spring Core 模块,用来创建和管理 Bean,默认使用单例的方式将 bean 存储在 DefaultListableBeanFactory 类的 beanDefinitionMap 中(一个ConcurrentHashMap 类型的Map集合);
- IOC 容器使用 ConcurrentHashMap 集合存储了 BeanDefinition 对象,对该对象封装了 Spring 对一个 Bean 所有配置信息,包括:类名、属性、构造方法参数、依赖、是否延迟加载、是否是单例等配置信息;
05. Spring DI 的理解
- 关键词:名词解释
- DI (Dependency Inject, 中文释义: 依赖注入)是对 IOC 概念的不同角度的描述,是指应用程序在运行时,每一个 bean 对象都依赖于 Ioc 容器,Ioc 容器注入当前 bean 对象所需要的另外一个 bean 对象。(例如在 Mybatis 整合 Spring 时,SqlSessionFactoryBean 依赖 Ioc 容器注入一个 DaataSource 数据源 bean);