目录
一 、开发工具安装及配置
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
在pom.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
/** * @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
public 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
public interface IUserDao { public void save(); } public class UserDaoImp implements IUserDao{ public void save() { System.out.println("====dao的新增===="); } }service
public 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
public 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
/** * @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容器
<bean id="唯一标识" class="类的完全限定名称"></bean>3.以解耦方式获取javaBean实例对象
3.1加载spring主配置文件，获取spring核心对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");3.2获取javaBean
Student student = (Student) applicationContext.getBean("student");实现：
在pom.xml配置
<dependencies> <!-- spring --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.12</version> </dependency> </dependencies>新建类
controller
public interface IUserController { public void save(); } public class UserControllerImp implements IUserController{ public void save() { System.out.println("====controller的新增===="); } }dao
public interface IUserDao { public void save(); } public class UserDaoImp implements IUserDao{ public void save() { System.out.println("====dao的新增===="); } }service
public interface IUserService { public void save(); } public class UserServiceImp implements IUserService{ public void save() { System.out.println("====service的新增===="); } }pojo
public class Student { private String stuName; private String stuHobby; private int stuAge; get、set 构造方法 tostring 省略 }2.将需要spring管理的类，注入springIOC容器
main-》resources下 new -》xml->SpringConfig
beans.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
/** * @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 Demo03
BeansFactory 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.配置
<property 属性名="属性值"></property> 属性： name：属性名 ref：注入的值的引用 value：注入的值di实现步骤（构造）
- 1.思考
- 2.提供对应方法（构造）
- 3.配置
<constructor-arg 属性名="属性值"></constructor-arg> 属性： name：属性名 type: 参数类型 index: 参数下标 ref：注入的值的引用 value：注入的值总结IOC-DI：
原来要对象，自己造自己用
现在要对象，容器造，容器拼一起，自己用
spring胶水框架
set注入
实现：set注入 javaBean对象
在poi.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
<!-- 注入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
public 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
public interface IUserDao { public void save(); } public class UserDaoImp implements IUserDao{ public void save() { System.out.println("====dao的新增===="); } }service
public 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
** * @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
public class Student { private String stuName; private String stuHobby; private int stuAge; set tostring 省略 }beans.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
public class Teacher { private List mylist; private Set myset; private String[] myarray; private Map mymap; private Properties prop; set tostring 省略 }beans.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>测试：
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(); Student student = (Student)applicationContext.getBean("student"); System.out.println(student); Teacher teacher = (Teacher)applicationContext.getBean("teacher"); System.out.println(teacher); } }
构造注入
实现：构造注入 基本类型与String
pojo
Student
public class Student { private String stuName; private String stuHobby; private int stuAge; 构造方法 无参 有参 tostring 省略 }beans.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>测试：
public 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
public 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
<!-- =========================构造注入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>测试
public 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）；
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
