Spring - 入门

最新推荐文章于 2023-03-09 00:25:44 发布
最新推荐文章于 2023-03-09 00:25:44 发布
阅读量365 收藏 3
点赞数 2
分类专栏： Spring 文章标签： mybatis spring java 编程语言 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45181415/article/details/114546689
版权
本文介绍了Spring框架的基本概念、优势和分层架构，重点讲解了IoC和DI的概念，以及如何通过Spring进行资源注入和配置。还通过实际案例演示了如何整合Spring与MyBatis，实现账户模块的CRUD操作。
摘要由CSDN通过智能技术生成

Spring

1)Spring简介

1.1)什么是框架

  • 源自于建筑学，隶属土木工程，后发展到软件工程领域

  • 软件工程中框架的特点：

    • 经过验证

    • 具有一定功能

    • 半成品

1.2)框架的优势

  • 提高开发效率
  • 增强可重用性
  • 提供编写规范
  • 节约维护成本
  • 解耦底层实现原理

既然软件工程中的框架有这么多的优势，那广大软件工程师就就很有必要去学习和使用框架。

1.3)Spring是什么

Spring是分层的JavaSE/EE应用full-stack轻量级开源框架。

分层：针对三层架构设计: Controller层（WEB层）-> Service层（业务层）-> 数据层（DAO）

full-stack（全栈）：Spring功能非常强大，能够服务于Java开发过程中的各个层面

轻量级：资源消耗较低，运行速度较快

1.4)Spring的体系结构

在这里插入图片描述

两大核心：

  • IoC：控制反转
  • AOP：面向切面编程（一种编程思想）

1.5)Spring的发展历史

作者：Rod Johnson 罗宾·约翰逊

在这里插入图片描述

1.6)Spring优势

Spring的优势
方便解耦，简化开发第一天
方便集成各种优秀框架，比如MyBatis第一天
方便程序的测试，集成JUnit第二天
AOP编程的支持第三天
声明式事务的支持第四天
Java源码是经典学习范例长期学习

2)IoC简介

2.1)回顾数据库查询

在这里插入图片描述

2.2)耦合与内聚

  • 耦合（Coupling）：用于衡量软件中各个模块之间的互联程度。

  • 内聚（Cohesion）：代码书写过程中单个模块内部各组成部分间的联系，用于衡量软件中各个功能模块内部的功能联系，比如UserServiceImpl中的增删查改需要写到一个类中

  • 优质程序代码的制作原则：高内聚，低耦合

    保证同一个模块内的各个功能之间要高度紧密，但是尽量降低多个模块之间的相互依赖

2.3)工厂模式发展史

  • UserServiceImpl中需要调用userDao对象：自己通过new UserDaoImpl()产生对象

  • UserServiceImpl中需要调用userDao对象：通过UserDao工厂类获取

  • UserServiceImpl中需要调用userDao对象：在工厂类中读取配置文件通过反射产生UserDao的对象

2.4)IoC衍生过程

在这里插入图片描述

2.5)IoC概念

  • IoC（Inversion Of Control）控制反转，Spring反向控制应用程序所需要使用的外部资源。举例
  • Spring控制的资源将全部放置在Spring容器中，该容器称为IoC容器
  • IoC是面向对象编程的一种设计原则，可以用来降低代码之间的耦合度

3)入门案例(重点)

3.1)案例环境说明

  • 模拟三层架构中表现层调用业务层功能

  • 表现层：UserApp（使用main方法）模拟UserServlet

  • 业务层：UserService

3.2)IoC入门案例制作步骤

1.导入spring坐标（5.1.9.RELEASE）

2.编写业务层接口与实现类

3.建立spring配置文件：resources\applicationContext.xml

4.配置所需资源（Service）为spring控制的资源

5.表现层（App）通过spring获取资源（Service实例）

3.2.1)导入Spring坐标
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
</dependencies>
3.2.2)编写业务层接口和实现类
public interface UserService {
	//业务方法  
	void save();
}

public class UserServiceImpl implements UserService {
    public void save() {
        System.out.println("user service running...");
    }
}
3.2.3)编写Spring配置文件

src\main\resources\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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
</beans>
3.2.4)配置UserServiceImpl为Spring控制的资源
<!-- 1.创建spring控制的资源-->
<bean id="userService" class="com.ithe.service.impl.UserServiceImpl"/>
3.2.5)模拟表现层调用业务层
public class UserApp {
    public static void main(String[] args) {
        //2.加载配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //3.获取资源
        UserService userService = (UserService) ctx.getBean("userService");
        userService.save();
    }
}

4)IoC配置（XML格式）

4.1)bean

  • 名称：bean

  • 类型：标签

  • 归属：beans标签

  • 作用：定义spring中的资源，受此标签定义的资源将受到spring控制

  • 基本属性：

    <bean id="userService" name="userService1, userService2" class="com.service.impl.UserServiceImpl"/>

    ​ id：bean的名称，通过id值获取bean

    ​ class：bean的类型

    ​ name：bean的名称，可以通过name值获取bean，用于多人共同开发时给bean起别名

4.2)bean属性scope

  • 名称：scope（范围，作用域）

  • 类型：属性

  • 归属：bean标签

  • 作用：定义bean的作用范围

  • 格式：

    <bean scope="singleton" />

  • 取值：

    • singleton：设定创建出的对象保存在spring容器中，是一个单例的对象
    • prototype：设定创建出的对象保存在spring容器中，是一个非单例的对象
    • request、session、application、 websocket ：设定创建出的对象放置在web容器对应的位置
    public class UserServiceImpl implements UserService {

    //通过构造方法判断实例化了几次
    public UserServiceImpl(){
        System.out.println(" constructor is running...");
    }
}

4.3)bean生命周期

  • 名称：init-method，destroy-method

  • 类型：属性

  • 归属：bean标签

  • 作用：定义bean对象在初始化或销毁时完成的工作

  • 格式：

    <bean id="userService3" init-method="init" destroy-method="destroy"
      class="com.service.impl.UserServiceImpl"/>

  • 取值：bean对应的类中对应的具体方法名

  • 在UserServiceImpl中编写init()和destroy()

    public void init(){
    System.out.println("init....");
}

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

  • 如果需要执行destroy()，必须手动调用ClassPathXmlApplicationContext对象的close的方法

    ctx.close();

    public class UserApp {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(
        "applicationContext.xml");
        UserService userService = (UserService) ctx.getBean("userService5");
        userService.save();
        ctx.close();
    }
}

  • 注意事项：

    • 当scope=“singleton”时，spring容器中有且仅有一个对象，init方法在创建容器时仅执行一次
    • 当scope=“singleton”时，关闭容器会导致bean实例的销毁，调用destroy方法一次
    • 当scope=“prototype”时，spring容器要创建同一类型的多个对象，init方法在每个对象创建时均执行一次
    • 当scope=“prototype”时，对象的销毁由垃圾回收机制gc()控制，destroy方法将不会被执行

4.5)DI

  • IoC（Inversion Of Control）控制反转

    Spring反向控制应用程序所需要使用的外部资源

  • DI（Dependency Injection）依赖注入

    应用程序运行依赖的资源由Spring为其提供，资源进入应用程序的方式称为注入

  • IoC与DI的关系：同一件事站在不同角度看待问题

4.6)set注入(重点)

  • 名称：property

  • 类型：标签

  • 归属：bean标签

  • 作用：使用set方法的形式为bean提供资源

  • 格式：

    <bean>
	<property />
</bean>

  • 基本属性：

    • 引用类型：自定义类产生的对象，使用ref指定
    • 非引用类型：基本数据类型(int, char,…)和特殊类型String，使用value指定
    <!--非引用类型注入-->
<property name="propertyName" value="propertyValue" />

<!--引用类型注入-->
<property name="propertyName" ref="beanId"/>

​ name：对应bean中的属性名，要求该属性必须提供可访问的set方法（严格规范：此名称是set方法对应名称）

​ value：设定非引用类型属性对应的值，不能与ref同时使用

​ ref：设定引用类型属性对应bean的id ，不能与value同时使用

  • 使用set注入

    1. 在UserServiceImpl中添加三个属性，并添加set方法

      public class UserServiceImpl implements UserService {

    /*
        1. 基本数据类型：int, char
        2. 特殊类型：String
        3. 引用类型：自定义类产生的对象
     */
    private int num;
    private String version;

    private UserDao userDao;

    //1.对需要进行诸如的变量添加set方法
    public void setNum(int num) {
        this.num = num;
    }

    public void setVersion(String version) {
        this.version = version;
    }

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

    public void save() {
        System.out.println("user service running..."+num+" "+version);
        userDao.save();
    }
}

    2. 在applicationContext.xml中完成set注入的配置

      <!--2.将要注入的资源声明为bean-->
<bean id="userDao" class="com.dao.impl.UserDaoImpl"/>

<bean id="userService" class="com.service.impl.UserServiceImpl">
    <!--3.将要注入的引用类型的变量通过property属性进行注入，对应的name是要注入的变量名，使用ref属性声明要注入的bean的id-->
    <!--reference 引用类型-->
    <!--setUserDao()-->
    <property name="userDao" ref="userDao"/>
    <!--setNum-->
    <property name="num" value="666"/>
    <!--setVersion-->
    <property name="version" value="it"/>
</bean>

    3. 获取userService验证是否注入成功

      ApplicationContext ctx =
        new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) ctx.getBean("userService");
userService.save();

  • 易错点：类中必须写set方法

  • xml中的== 代码中的setXxx()

小结

  1. 类中必须写set方法
  2. bean中使用property标签注入属性
  3. name表示注入的属性名
  4. 引用类型：使用ref进行注入
  5. 其他：使用value进行赋值注入

4.11)properties文件(重点)

  • Spring提供了读取外部properties文件的机制，使用读取到的数据为bean的属性赋值

  • 操作步骤

    1.准备外部data.properties文件，放置在src\main\resources目录下

#系统环境变量中存在username,在cmd中使用echo %username%查看
#username=root
username=root
pwd=root


2.开启context命名空间支持

```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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

​ 3.加载指定的properties文件

<context:property-placeholder location="classpath:filename.properties" />

​ 4.使用加载的数据

<property name="propertyName" value="${propertiesName}"/>

  • 注意：如果需要加载多个properties文件，可以使用*.properties表示加载所有的properties文件

  • 注意：读取数据使用**${propertiesName}格式进行，其中propertiesName**指properties文件中的属性名

  • 注意和系统环境变量的冲突

    cmd 
echo %JAVA_HOME%
echo %username%

    扩展知识：使用local-override属性覆盖操作系统中的环境变量

    <context:property-placeholder location="classpath:filename.properties" 
                              local-override="true" />

4.12)多配置文件

Spring多配置文件的使用方式：使用import即可。

  • 名称：import

  • 类型：标签

  • 归属：beans标签

  • 作用：在当前配置文件中导入其他配置文件中的项

  • 第一种导入方式（常用）：使用import标签配置resource：加载的配置文件名

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

  • 第二种方式Spring容器加载多个配置文件（了解）

    new ClassPathXmlApplicationContext("config1.xml","config2.xml");

  • Spring容器中的bean定义冲突问题

    • 同id的bean，后定义的覆盖先定义的

    • 导入配置文件可以理解为将导入的配置文件复制粘贴到对应位置

    • 导入配置文件的顺序与位置不同可能会导致最终程序运行结果不同

4.13)ApplicationContext(了解)

使用BeanFactory

Resource res = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(res);
//UserService userService = (UserService)bf.getBean("userService");

4.14)第三方资源配置(重点)

  • 回顾之前Druid使用方式

    //获取配置文件的流对象
InputStream is = DruidTest1.class.getClassLoader().getResourceAsStream("druid.properties");

//1.通过Properties集合，加载配置文件
Properties prop = new Properties();
prop.load(is);

//2.通过Druid连接池工厂类获取数据库连接池对象
//driverClassName=com.mysql.jdbc.Driver
//url=jdbc:mysql://192.168.59.129:3306/db14
//username=root
//password=ithe
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

  • 引入Druid坐标

    <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

  • 使用Spring配置Druid数据源

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
</bean>

5)综合案例(重点)

5.1)案例介绍

  • 使用spring整合mybatis技术，完成账户模块（Account）的基础增删改查功能

  • 账户模块对应字段

    • 编号：id

    • 账户名：name

    • 余额：money

5.2)案例分析

5.3)基础准备工作

  • 环境准备：导入Spring坐标，MyBatis坐标，MySQL坐标，Druid坐标

    <dependencies>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.3</version>
    </dependency>
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.16</version>
    </dependency>
</dependencies>

  • 业务类与接口准备

    1. 创建数据库表，并制作相应的实体类Account
    2. 定义业务层接口与数据层接口
    3. 在业务层调用数据层接口，并实现业务方法的调用

  • 基础配置文件

    1. jdbc.properties
    2. MyBatis映射配置文件

5.4)整合准备工作

1.spring配置文件，加上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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

2.开启加载properties文件

<context:property-placeholder location="classpath:jdbc.properties"/>

3.配置数据源Druid

<!--加载druid资源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

4.定义service层bean，并使用property标签注入dao

<!--配置service作为spring的bean,注入dao-->
<bean id="accountService" class="com.ithe.service.impl.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"/>
</bean>

5.dao的bean无需定义，MyBatis会自动生成代理对象

5.5)整合工作

1.导入Spring整合MyBatis坐标

<!--Spring整合MyBatis坐标-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>

2.将mybatis配置成spring管理的bean（SqlSessionFactoryBean），并将类型别名交由spring处理

<!--spring整合mybatis后控制的创建连接用的对象-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/> 
    <property name="typeAliasesPackage" value="com.ithe.domain"/>
</bean>

3.通过spring加载mybatis的映射配置文件到spring环境中（映射Mapper扫描工作交由spring处理）

<!--加载mybatis映射配置的扫描，将其作为spring的bean进行管理-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.ithe.dao"/>
</bean>

4.使用spring环境获取业务层bean，执行操作

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        AccountService accountService = (AccountService) ctx.getBean("accountService");

        //查询
        Account ac = accountService.findById(13);
        System.out.println(ac);

        //保存
        Account account = new Account();
        account.setName("jack");
        account.setMoney(123456.78);
        accountService.save(account);
    }
}
魏帅坤
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
IOC操作Bean管理（基于注解方式）
m0_57448314的博客
12-02 1096
注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值）使用注解，注解作用于类上面，方法上面，属性上面使用注解目的，简化xml配置。
最详细的Spring-data-jpa入门（一）
此成非彼诚博客
08-13 10万+
刚进公司，人生地不熟，偷偷藏着本《mybatis入土为安》，以为可以靠mybatis混的轻松点，谁知天有不测风云，大家用的是JPA。我这个小白没有听说过，全英文名叫，就是java持久化api，是SUN公司推出的一套基于的规范。持久化想必如雷贯耳，都0202年了，谁还不用个持久化框架啊，举起mybatis。ORM呢？全英文名为：对象关系映射，简单来说为了不用JDBC那一套原始方法来操作数据库，ORM框架横空出世（mybatis、hibernate等等）。...
Spring的相关知识
个人学习所用博客，记录日常学习的过程。
05-04 949
Spring一、概述二、入门案例三、IOC容器1、IOC底层原理（1）什么是IOC（2）IOC底层原理（3）图解2、IOC接口3、IOC操作（Bean管理）概述4、基于xml方式的Bean管理（1）基于xml方式创建对象（2）基于xml方式注入属性DI：依赖注入（注入属性）（3）基于xml方式注入空值和特殊符号（4）基于xml方式注入外部bean（5）基于xml方式注入内部bean和级联赋值（6）基于xml方式注入集合属性（7）基于xml方式注入集合属性（2）5、Bean管理之FactoryBean6、Be
Spring注入
最新发布
欢迎阅读我的博客
03-09 300
准备一个UserDao类和UserService类 , 其中 UserService类中有UserDao类型的属性 注入外部Bean(常用) 注入外部Bean的方式：在外部注册一个bean, 然后通过外部bean的id配合property标签的ref引用属性进行注入 注入内部Bean(了解) 注入内部Bean的方式：在bean标签中嵌套bean标签 , 内部bean的id是没有用的 , 不能通过容器被获取到所以不用写id set 注入的核心实现原理 set注入是基于set方法实现的，底层会通过反射机制调用属
spring的bean的属性4种注入和复杂属性注入简单介绍
qq_36697880的博客
06-28 1528
文章自己学习使用，比较简单。 属性在创建对象的时候给属性注入值。1 属性注入之 setter方法：  &lt;!-- 使用set 方法注入属性 --&gt;      &lt;bean id="propertyDemo2" class="com.springTest.serterTest.PropertyDemo1"&gt;         &lt;!-- 给userName和age注入值 --&...
Spring基础-基础注解
WangXiong的博客
05-11 128
1、基础的基础概念
spring-boot-starter-mybatis:Spring Boot MyBatis入门
05-14
与官方相反，它遵循其他Spring Boot数据存储库的约定并实现适当的Spring Data接口。 这种方法的优点是在切换持久层上几乎无需花费任何努力。 问题跟踪 Maven依赖 < groupId>com.create</ groupId> < artifactId>...
spring-boot-starter-api-doc:Spring Boot Web API文档生成入门
05-02
API Document Generate Spring Boot Project 如何使用 1. 编译安装 mvn clean install 2.添加依赖至WEB项目 <groupId>top.webdevelop.gull <artifactId>spring-boot-starter-api-doc <version>1.0.RELEASE 3. ...
problem-spring-web：用于处理Spring Web MVC中的问题的库
02-03
Spring MVC和Spring WebFlux的问题 问题Spring Web是一组库，可轻松从Spring应用程序生成响应。 它填补了一个小众市场，它连接了和或从而使它们可以无缝地协同工作，而只需最少的开发人员工作。 在此过程中，它旨在...
rocketmq-spring-boot-starter：RocketMQ的Spring Boot启动器
01-30
简单入门实例 1.添加maven依赖： < groupId> com . maihaoche < / groupId > < artifactId> spring - boot - starter - rocketmq < / artifactId > < version> 0.1 . 0 < / version > < / ...
Spring
起feng了~'s blog
10-12 115
### Spring概述 概念:是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和AOP（Aspect Oriented Programming：面向切面编程）为内核。 提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整 合开源世界...
java反射的那点事
qq_37497275的博客
06-10 1870
import com.herbert.aj.shose.model.SShoseInfo; import java.beans.BeanInfo; import java.beans.IntrospectionException; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java....
03-Spring相关
weixin_46449115的博客
09-03 139
spring总结 一、spring中的ioc 所谓的IOC一句话搞定：对象由Spring 来创建，管理，装配。ioc叫做控制反转，是spring的核心 ioc是一种思想 ，有一些实现方式，其中较为常用的一种是依赖注入(Dependency Injection，简称DI)，依赖注入是指程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。 实现方式，依赖注入，注入bean让spring去管理。默认bean的作用域是单例的singleton 依赖注
Spring的bean管理（注解注入属性和注解文件混合使用）
zhupengqq的博客
05-30 3738
Spring的bean管理（注解注入属性和注解文件混合使用） 注解方式注入属性  1 创建service类，创建dao类，在service得到dao对象     注入属性第一个注解 @Autowired     （1） 创建dao和service对象              (2) 在service类里面定义到类型属性         注入属性第一个注解
Spring三种注入属性的方式
程序媛的博客
09-05 3743
Spring三种方法注入属性 1.        准备工作： 1)        新建Dao包，Service包 2)        在每个包内新建对应的接口，以及impl包 UserDao public interface UserDao {     public void TestDao(); } UserService public interface Use
Spring 报错：Error creating bean with name的解决方法
热门推荐
梅森上校的博客 业精于勤荒于嬉，形成于思毁于随。
01-02 10万+
Spring报错：Error creating bean with name的解决方法
struts笔记
WangLili_0414的博客
03-27 210
Struts2的作用 1、action: 新建web project java版本 设置 window server tomcat位置enable window prefernce installed jdk版本 软件包：struts-2.1.6 拷贝文件struts.xml 到src 类库文件：lib下； 全考出了juni 与spring...
JAVA进阶之Spring
weixin_44205039的博客
10-15 194
Spring 官网：https://spring.io 优秀的java开源框架。 作用：项目管理。 管理组件(对象 DAO，Service，Controller)。 设计思路：践行工厂模式，打造一个工厂，通过工厂完成对项目的管理。 spring工厂搭建 1. 导入依赖 <dependency> <groupId>org.springframework</gr...
Just Spring - 入门指南
"Just Spring" 是一本由Oreilly出版的Spring框架入门书籍，由Spring大师Madhusudhan Konda撰写。这本书以英文版呈现，旨在帮助读者理解并掌握Spring的核心概念，包括IOC（控制反转）和AOP（面向切面编程）。 Spring...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值