maven工程和springmvc的相关知识点总结（没有整合ssm）

于 2023-09-12 17:02:16 发布
阅读量152 收藏
点赞数
文章标签： maven pycharm java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhahahhahahhha/article/details/132834072
版权

1maven

1、当前的项目中会依赖大量的jar包，而jar包之间的依赖关系非常的复杂，缺少jar包或者多了jar包，甚至jar包的版本不匹配，都会给项目带来严重的问题。

2、以往开发项目时，程序员往往需要花较多的精力在引用Jar包搭建项目环境上，而这一项工作尤为艰难，少一个Jar包、多一个Jar包往往会报一些让人摸不着头脑的异常。

3、Maven就是一款帮助设计者开发项目的工具，能自动的帮助程序员将需要的jar包以及对应依赖包自动的下载下来。极大的提高了开发的效率。

2配置maven环境变量

在这之前配一个maven-home的路径，路径就是maven包的路径，建议放在c盘，用户下

.m2最好。

测试安装成功没有，打开cmd：输入以下命令

2.2在Eclipse中配置Maven工具

3什么是maven仓库

Maven仓库用来存放Maven管理的所有Jar包。分为：本地仓库 和 中央仓库。

本地仓库：Maven本地的Jar包仓库。

中央仓库： Maven官方提供的远程仓库。

           中央仓库地址：https://mvnrepository.com/

当项目编译时，Maven首先从本地仓库中寻找项目所需的Jar包，若本地仓库没有，再到Maven的中央仓库下载所需Jar包。

4maven配置

4.1maven的中央仓库位置

<mirrors>
	<mirror>
      <id>nexus-aliyun</id>
      <mirrorOf>central</mirrorOf>
      <name>Nexus aliyun</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public</url>
    </mirror>
  </mirrors>

在.m2里的setting.xml,文件中找到

<mirrors>

  </mirrors>

将内容改成阿里云的maven仓库。

4.2maven修改jdk版本

<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

这个也是在.m2里的setting.xmlzhong添加。

找到maven目录下的conf/settings.xml文件，在<profiles></profiles>之间增加以下内容：

<profile>
		<id>jdk-1.8</id>
		<activation>
			<activeByDefault>true</activeByDefault>
			<jdk>1.8</jdk>
		</activation>
		<properties>
			<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
			<maven.compiler.source>1.8</maven.compiler.source>    
			<maven.compiler.target>1.8</maven.compiler.target>    
			<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>    
		</properties>
	</profile>

5认识spring

spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。

Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

它是一个容器框架，用来装javabean（java对象），中间层框架（万能胶）可以起一个连接作用，比如说把Struts和hibernate粘合在一起运用。简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

什么是spring?

概念：spring是一个开源的框架，管理其他的框架，

核心：Spring是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架。

5.1什么是springIOC

IOC不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

总结：IOC:本质就是将原先由自己管理对象的生命周期，现在交给spring工厂去统一的管理bean的生命周期。

5.2.1认识IOC和DI

IOC— Inversion of Control:

控制反转：就是将对象的生命周期交给spring负责

DI—Dependency Injectio:--将spring创建的对象赋值给类中的空引用。

依赖注入：通过bean中的property给类中的属性赋值。

总结：就是将由spring创建的对象引用赋值到我们自己创建的引用中。

5.2.2spring容器加载的三种方式

在 Spring 框架中，有三种常见的方式用于加载容器：

  1. XML 配置文件：使用 XML 配置文件是传统和最常见的一种 Spring 容器加载方式。在 XML 配置文件中，你可以定义各种 Bean 的配置信息，包括类路径下的组件扫描、Bean 的定义、Bean 之间的依赖关系等。通过读取和解析 XML 配置文件，Spring 容器可以创建和管理相应的 Bean 实例。

示例 XML 配置文件：

<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 -->
    <bean id="userService" class="com.example.UserService">
        <property name="userDao" ref="userDao"/>
    </bean>

    <bean id="userDao" class="com.example.UserDao"/>

</beans>
  1. Java 配置类：Java 配置类是一种基于代码方式配置 Spring 容器的方式，可以替代 XML 配置文件。通过使用 @Configuration 和 @Bean 注解，你可以创建一个 Java 配置类，并在其中定义各种 Bean 的配置信息。Spring 容器会根据 Java 配置类的定义来创建相应的 Bean 实例。

示例 Java 配置类：

@Configuration
public class AppConfig {

    @Bean
    public UserService userService(UserDao userDao) {
        UserService userService = new UserService();
        userService.setUserDao(userDao);
        return userService;
    }

    @Bean
    public UserDao userDao() {
        return new UserDao();
    }

}
  1. 注解扫描：使用注解扫描是一种方便的 Spring 容器加载方式，它会自动扫描指定包及其子包下的所有注解，并将被标注的类注册为 Bean。通过在类上添加 @Component 及其衍生注解（如 @Service、@Repository、@Controller 等），你可以将类声明为一个组件，并由 Spring 容器进行管理。

示例注解扫描：

@ComponentScan(basePackages = "com.example")
@Configuration
public class AppConfig {
    // 所有被@Component注解的类会被自动注册为bean
}

在实际使用中，可以根据具体需求选择以上任意一种方式来加载 Spring 容器。通常，XML 配置文件适用于传统的大型项目；Java 配置类提供了更强的类型安全和编程能力；注解扫描则适用于快速开发和便捷配置。你也可以组合使用多种方式，以满足不同场景的需求。

5.3java配置类怎么使用

要使用 Java 配置类来配置 Spring 容器，你需要按照以下步骤进行操作：

  1. 创建一个普通的 Java 类，并在类上添加 @Configuration 注解，将其标记为配置类。
@Configuration public class AppConfig { // 配置信息和Bean定义 }
  1. 在配置类中使用 @Bean 注解来定义需要被容器管理的 Bean
@Bean public UserService userService(UserDao userDao) {
 UserService userService = new UserService(); 
userService.setUserDao(userDao); return userService;
 }
 @Bean public UserDao userDao() {
 return new UserDao();
 }
  1. 可选地，在 @Bean 注解中可以指定 Bean 的名称，如果不指定，默认使用方法名作为 Bean 的名称。
@Bean("myUserService") public UserService userService(UserDao userDao) { // ... }
  1. 在应用程序的入口处，创建一个 AnnotationConfigApplicationContext 对象，并传入配置类的类对象

public static void main(String[] args) { 
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); // ... }
  1. 通过 getBean() 方法从容器中获取所需的 Bean。
UserService userService = context.getBean(UserService.class);

注意事项：

  • 确保配置类所在的包路径被扫描到，可以使用 @ComponentScan 注解或手动配置 basePackages 参数来指定扫描的包。
  • 如果你的项目中同时存在 XML 配置文件和 Java 配置类，可以在创建容器时，同时指定 Java 配置类和 XML 配置文件的路径。
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class, "classpath:applicationContext.xml");

通过以上步骤，你就可以使用 Java 配置类来配置和加载 Spring 容器，并且获取所需的 Bean。Java 配置类提供了更直观和类型安全的方式来定义 Bean，同时也便于进行版本控制和重构。

5.4spring实例化配置文件中bean的三种方式

在 Spring 框架中，实例化配置文件中的 Bean 有三种方式：

  1. 构造器方式：使用构造器方式创建 Bean 实例时，需要定义 Bean 的属性及其对应值，并将其注入到 Bean 实例中。在 XML 配置文件中，可以使用 <constructor-arg> 元素来完成这一过程。

示例 XML 配置：

<bean id="userController" class="com.example.UserController"> <constructor-arg name="userService" ref="userService"/> </bean> 
<bean id="userService" class="com.example.UserService"> <constructor-arg name="userDao" ref="userDao"/> </bean> 
<bean id="userDao" class="com.example.UserDao"/>
  1. 工厂方法方式：使用工厂方法方式创建 Bean 实例时，需要定义一个工厂类和对应的工厂方法，并将工厂类和工厂方法以及参数传递给 Spring 容器。在 XML 配置文件中，可以使用 <bean> 元素的 factory-bean 和 factory-method 属性来完成这一过程。

示例 XML 配置：

<bean id="userController" class="com.example.UserController"> <property name="userService" ref="userService"/> </bean> 
<bean id="userServiceFactory" class="com.example.UserServiceFactory"> <property name="userDao" ref="userDao"/> </bean>
 <bean id="userService" factory-bean="userServiceFactory" factory-method="createUserService"/>
 <bean id="userDao" class="com.example.UserDao"/>
  1. 静态工厂方法方式：使用静态工厂方法方式创建 Bean 实例时，需要定义一个工厂类和对应的静态工厂方法，并将工厂类和工厂方法以及参数传递给 Spring 容器。在 XML 配置文件中，可以使用 <bean> 元素的 class 属性和 factory-method 属性来完成这一过程。

示例 XML 配置：

<bean id="userController" class="com.example.UserController"> <property name="userService" ref="userService"/> </bean>
 <bean id="userService" class="com.example.UserServiceFactory" factory-method="createUserService"> <constructor-arg name="userDao" ref="userDao"/> </bean>
 <bean id="userDao" class="com.example.UserDao"/>

以上三种方式都可以实现在 Spring 容器中创建并管理 Bean 实例，具体选择哪种方式，取决于你的业务场景和个人偏好。总的来说，构造器方式是最常用的一种方式，可以满足大部分需求；工厂方法方式和静态工厂方法方式则更加灵活，可以更好地支持特殊的创建需求。

5.5bean的作用域：

1.    singleton：

<bean id="userInfo" class="cn.lovepi.UserInfo" scope="singleton"></bean>  

当Bean的作用域为singleton的时候,Spring容器中只会存在一个共享的Bean实例，所有对Bean的请求只要id与bean的定义相匹配，则只会返回bean的同一实例。单一实例会被存储在单例缓存中，为Spring的缺省作用域。

2.    prototype：

<bean id="userInfo" class="cn.lovepi.UserInfo" scope=" prototype "></bean>  

每次对该Bean请求的时候，Spring IoC都会创建一个新的作用域。

对于有状态的Bean应该使用prototype，对于无状态的Bean则使用singleton

3.    request：

<bean id="userInfo" class="cn.lovepi.UserInfo" scope=" request "></bean>  

Request作用域针对的是每次的Http请求，Spring容器会根据相关的Bean的

定义来创建一个全新的Bean实例。而且该Bean只在当前request内是有效的。

4.    session：

<bean id="userInfo" class="cn.lovepi.UserInfo" scope=" session "></bean>  

针对http session起作用，Spring容器会根据该Bean的定义来创建一个全新的Bean的实例。而且该Bean只在当前http session内是有效的。

5.    global session：

<bean id="userInfo" class="cn.lovepi.UserInfo"scope=“globalSession"></bean>  

类似标准的http session作用域，不过仅仅在基于portlet的web应用当中才有意义。Portlet规范定义了全局的Session的概念。他被所有构成某个portlet外部应用中的各种不同的portlet所共享。在global session作用域中所定义的bean被限定于全局的portlet session的生命周期范围之内。

5.6spring0-DIbean属性的方式

在 Spring 中，可以使用以下几种方式来进行依赖注入（Dependency Injection）设置 Bean 的属性：

  1. 构造器注入（Constructor Injection）：通过构造方法来注入依赖。在 XML 配置文件中，可以使用 <constructor-arg> 元素来指定构造器参数的值。

示例 XML 配置：

<bean id="userService" class="com.example.UserService"> <constructor-arg ref="userDao"/> </bean>
  1. Setter 方法注入（Setter Injection）：通过 setter 方法来注入依赖。在 XML 配置文件中，可以使用 <property> 元素来设置属性的值。

示例 XML 配置：

<bean id="userService" class="com.example.UserService"> <property name="userDao" ref="userDao"/> </bean>
  1. 接口注入（Interface Injection）：通过接口方法来注入依赖。这种方式较少使用，一般在特殊情况下才会使用。在 XML 配置文件中，可以使用 <lookup-method> 元素来配置接口方法注入。

示例 XML 配置：

<bean id="userService" class="com.example.UserService"> <lookup-method name="getUserDao" bean="userDao"/> </bean> <bean id="userDao" class="com.example.UserDao"/>
  1. 注解注入（Annotation Injection）：使用注解方式来注入依赖。在类中使用 @Autowired、@Resource 或 @Inject 注解来标记需要注入的属性或构造器。

示例 Java 配置类：

@Configuration public class AppConfig {
 @Bean public UserService userService() {
 return new UserService();
 } 
@Bean public UserDao userDao() { 
return new UserDao(); 
} 
}

示例注解使用：

@Service public class UserService { @Autowired private UserDao userDao; // ... }

以上是Spring中进行DI（依赖注入）设置Bean属性的几种方式。你可以根据具体的需求选择适合的方式来注入属性并创建 Bean 实例。

5.7spring0-DIbean属性的方式和spring实例化配置文件中bean的三种方式的区别

  1. 目的：这两个概念解决的问题不同。实例化配置文件中Bean的三种方式主要用于创建和配置Bean实例，包括构造器方式、工厂方法方式和静态工厂方法方式。而DI（依赖注入）设置Bean属性的方式关注的是将依赖注入到Bean中。

  2. 内容：实例化配置文件中Bean的三种方式是为了创建Bean实例，可以通过构造器或工厂方法来实例化Bean，并将它们组装起来。而DI设置Bean属性的方式是为了将Bean之间的依赖关系注入到Bean中，通常通过setter方法或接口方法来设置属性。

  3. 配置方式：实例化配置文件中Bean的三种方式使用XML配置文件来定义Bean的创建方式，包括使用<bean>元素、constructor-arg元素和工厂类信息等。而DI设置Bean属性的方式可以使用XML配置文件，也可以使用注解来完成，在XML中使用<property>元素来设置属性，在注解中使用@Autowired、@Resource或@Inject等注解来标记需要注入的属性。

  4. 使用场景：实例化配置文件中Bean的三种方式适用于创建和配置Bean的常规场景，可以满足大部分需求。而DI设置Bean属性的方式适用于解决Bean之间的依赖关系，通过注入属性来建立关联，从而实现松耦合和灵活性。

总而言之，实例化配置文件中Bean的三种方式主要关注Bean的创建和配置，而DI设置Bean属性的方式关注的是将依赖注入到Bean中。两者在Spring框架中起到不同的作用，可以根据具体的业务需求选择适用的方式来实现代码逻辑。

6springmvc

6.1servlet的不足支持

servlet是线程不安全的：使用共享变量的时候。

servlet的最大不足支持：线程不安全—当设计者设计出共享的参数。

使用起来不便利：

    String  id=request.getParameter(“id”);

功能比较单一：

    重定向，转发

servlet会造成web.xml文件数据冗余---不好管理。

servlet的机构设计，不利于项目的解耦合。

servlet的使用具有容器依赖性：依赖tomcat服务器。

servlet中的所有方法都必须通过deGet,doPost才能访问。

6.2什么是springMVC?

 就是用来替代之前的servlet作用控制层的位置

-- 使用了mvc架构模式思想，将web层进行 职责解耦

-- springMVC就是spring框架中的webmvc   spring-webmvc

-- 用来管理用户请求映射

  之前的请求:用户通过地址栏发送请求add.do,然后请求会到达web.xml，解析对应的urp-pattern,servle-name

6.3使用springmvc

6.3.1返回ModelAndView类型的参数

@RequestMapping("/test2.do")
	public ModelAndView  test2(){
		ModelAndView mv=new ModelAndView("index");//index是逻辑视图
		mv.addObject("username", "txc");
		return mv;
	}

6.3.2springmvc重新启用了方法括号

@RequestMapping(value="test3.do",method=RequestMethod.GET)
    public  String test3(String name){
   	 System.out.println("=====test3===="+name);
   	 return "index";
    }

这里的括号里的内容就是，在url地址发送请求中后面拼的值

6.3.3springmvc对session和request的支持较好

注意点:在Stuts2中如何使用session和request----ActionContext,ServletActionContext

@RequestMapping(value="test4.do",method=RequestMethod.GET)
    public  String test4(HttpServletRequest request,HttpSession session){
		request.setAttribute("username", "萧十一郎");
		session.setAttribute("username1", "小李飞刀李寻欢");
   	 return "index";

6.3.4springmvc中model的使用

@RequestMapping(value="test4.do",method=RequestMethod.GET)
    public  String test4(HttpServletRequest request,HttpSession session,Model model){
		request.setAttribute("username", "萧十一郎");
		session.setAttribute("username1", "小李飞刀李寻欢");
   	 return "index";
    }

​​​​​​​6.3.5springmvc的转发和重定向

程序默认是转发行为

【转发】

@RequestMapping(value="test6.do",method=RequestMethod.GET)
    public  String test6(){
		
   	 return "forward:/WEB-INF/views/index.jsp";
    }

【重定向】

@RequestMapping(value="test6.do",method=RequestMethod.GET)
    public  String test6(){
		
   	 return "redirect:add.do";
    }

​​​​​​​6.3.6springmvc中modelmap的使用

@RequestMapping(value="test7.do",method=RequestMethod.GET)
    public  String test7(ModelMap mm){
		mm.put("username","路飞");
   	 return "index";
    }

6.3.7​​​​​​​springmvc对ajax的支持

使用之前需要考入对应的包支持。

<dependency>
           <groupId>com.fasterxml.jackson.core</groupId>
           <artifactId>jackson-databind</artifactId>
           <version>2.7.4</version>
       </dependency>
       <dependency>
          <groupId>com.fasterxml.jackson.core</groupId>
          <artifactId>jackson-core</artifactId>
          <version>2.7.4</version>
        </dependency>
        <dependency>
          <groupId>com.fasterxml.jackson.core</groupId>
          <artifactId>jackson-annotations</artifactId>
          <version>2.7.4</version>
       </dependency>
       <dependency>
          <groupId>org.codehaus.jackson</groupId>
          <artifactId>jackson-core-asl</artifactId>
          <version>1.9.10</version>
       </dependency>
       <dependency>
          <groupId>org.codehaus.jackson</groupId>
          <artifactId>jackson-mapper-asl</artifactId>
          <version>1.9.10</version>
       </dependency>

返回json类型的值

被@ResponseBody修饰，返回值会自动的转化成对应的json字符串。

@RequestMapping("/test8")
	@ResponseBody
	//返回jsonl类型的数据
	public Map<String,Object> test8(){
		Map<String, Object> map=new HashMap<String, Object>();
		map.put("flag", "1");
		map.put("stus",new Student("1","2","3","4","5","6"));
		return map;
	}

好了今天的分享就到这里了。

代码小周
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用Maven搭建是SpringMVC+Spring+Mybatis完整的Java项目
学弟不想努力了
05-21 1465
网上发布了不少关于搭建Spring+SpringMVC+Mybatis的技术文章，但是基本都是缺斤少两。我利用闲余时间自己搭建了一个完整的项目，希望对各位coder有所帮助，此项目仅供参考，自己搭建一遍才会有所收获。搭建过程中出现什么问题可以提出来大家一起解决。 开发工具：Eclipse 框架选型：SpringMVC、Spring、Mybatis 数据库：MySQL Jar包依赖方式：a...
Spring MVC+Maven 实现前端和后台交互源码
12-08
这是结合博客的源码，链接是：http://blog.csdn.net/u012660464/article/details/53508757 。名为：Spring MVC+Maven 实现同一项目的前端和后台交互，该源码示例了前端和后台如何进行参数的绑定传递。
SpringMVC + Maven 构建项目
BeCTOing的博客
06-22 305
SpringMVC + Maven 构建项目 springMVC是当下很流行的轻量级JavaEE架构设计，现将整个框架搭建过程记录下来，以备后期使用。 1.使用Eclipse创建一个maven项目 2.选择项目的工作空间 3.在所列选项中选择 xxx-webapp 1.0 4.输入项目名称mvc，点击finish 5.创建的项目目录结构如下： 6.在项目根目录下创建
Maven
buyue
07-19 1588
框架中使用的jar包，不仅数量庞大，而且彼此之间存在错综复杂的依赖关系。进一步增加了我们在jar包使用过程中的难度。Maven跟Spring没有关系，它们是两个不同的东西，Maven是自动化构建工具，在IDEA中使用Maven是为了更好的管理依赖、构建项目、管理项目信息。在javaweb的开发中，往往需要我们手动导入jar包，随着jar包的大规模增长，手动导入就难以管理。使用指令来手动执行操作，IDEA默认会把终端路径切换到当前项目的根目录，这里以项目。使用IDEA做开发时，一般直接点击右侧的。...
17.JAVA之三大框架Maven、Springboot、SpringMVC
最新发布
weixin_56027329的博客
05-06 1659
JAVA之三大框架Maven(eclipse和idea配置)、Springboot(eclipse和idea配置)、SpringMVC
使用IDEA基于Maven搭建多模块聚合工程（springmvc+spring+mybatis整合）
Sxuning123的博客
05-05 188
https://blog.csdn.net/sihai12345/article/details/80666764
Maven项目集成Spring MVC框架
zqq_2016的博客
03-12 483
一、Spring MVC简述 Spring MVC属于Spring Framework的后续产品，已经融合在Spring Web Flow里面。Spring框架提供了构建Web应用程序的全功能MVC模块。使用Spring可插入的MVC架构，从而在使用Spring进行Web开发时，可以选择使用Spring的Spring MVC架构或集成其他MVC开发框架。 二、在Web项目中集成Spring MVC框架 1. 在pom.xml文件中添加集成Spring MVC所需要的Maven依赖包和相关的属性值，具体
ssm110_springmvc和mybatis_birthjwe_整合ssm_
09-29
本项目“ssm110_springmvc和mybatis_birthjwe_整合ssm_”是针对Spring4、SpringMVC和MyBatis进行集成的实践案例，旨在帮助开发者理解并掌握这三大组件的整合流程。 **Spring Framework** Spring 是一个开源的Java...
Maven模块项目。整合spring+springmvc+mybatis
03-06
"Maven模块项目"就是这样一个示例，它演示了如何利用Maven的模块化特性，结合Spring、SpringMVC和MyBatis这三大流行Java Web开发框架进行项目整合。下面将详细介绍这些知识点。 首先，Maven是Apache软件基金会开发...
使用Maven整合ssm
04-13
Maven作为项目管理工具，是SSM整合的关键，它帮助开发者管理和构建项目，确保依赖关系的正确解决。 **一、Maven的理解与配置** Maven通过POM（项目对象模型）来描述项目，POM是一个XML文件（通常命名为pom.xml），...
SSM框架——(SpringMVC+Spring+MyBatis+Maven多模块)整合
01-27
SSM框架，全称为SpringMVC、Spring和MyBatis的整合框架，是JavaWeb开发中常见的技术栈，尤其适用于企业级应用。该框架结合了SpringMVC的控制层、Spring的服务层管理和MyBatis的数据访问层，形成了一套完整的解决方案...
maven项目（spring+springMVC+hibernate）
06-15
使用maven项目结构搭建的spring+springMVC+hibernate架构项目demo；
详细，maven整合Spring+SpringMVC+MyBatis
weixin_42556267的博客
06-27 2333
spring+spring MVC+MyBatis整合
Maven聚合方式整合SSM(Spring MVC+Spring+Mybatis)
输入技术、输出想法
05-26 364
Maven聚合方式整合SSM1. 父工程父工程依赖2. 基于Maven的Mybaits逆向工程pom.xmlgeneratorConfig.xml执行逆向生成操作的Maven命令逆向工程生成的资源各归各位2. Spring整合Mybaitsatcrowdfunding02-admin-webuipom.xmljdbc.propertiesmybatis-config.xmlspring-persist-mybatis.xmlatcrowdfunding03-admin-componentpom.xml测试数
在idea中使用maven，但不使用maven模板创建spring mvc项目-2
健康平安的活着的专栏
09-13 540
一.介绍说明 本案例使用maven创建springmvc项目，但没有使用到maven的创建模板，达成war包，部署到tomcat下执行。项目的最终结构，如下图所示： 二.构建项目 创建项目：02-spring-mvc-demo 2.1 使用maven创建项目 使用maven创建项目，但不使用maven的模板。 2.2 配置pom文件的依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://m.
（超详细）IDEA利用Maven 整合SSM (Springmvc + Spring + Mybatis)
weixin_44491927的博客
12-04 705
超详细 IDEA 版 Maven 整合SSM (Springmvc + Spring + Mybatis)
spring MVC maven等整合
gxftry1st的专栏
01-12 459
一. 框架详情 Spring 是一个轻量级的Java开发框架，它是为了解决企业应用开发的复杂性而创建的。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。 SpringMVC 属于SpringFrameWork的后
Maven项目整合MyBatis、Spring、Springmvc
weixin_54685622的博客
03-24 731
1. MyBatis简介(了解) 1.1. 什么是MyBatis MyBatis 本是apache的一个开源项目iBatis，2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注SQL本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集
SpringMVC实战教程：从入门到SSM整合
"SpringMVC.pdf 是一份关于Java后台开发中SpringMVC框架的详细教程，涵盖从入门到进阶的多个方面，包括快速入门、请求参数绑定、处理中文乱码、数据类型转换、Servlet API的使用、常用注解、Session和Cookie、Ajax...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值