idea创建spring项目（免直接spring.io官网下载jar包，本地导入，无例子），步步为营

在idea中新建spring项目，确实直接新建，然后等待其从官网下载好，是springframework 包+ 2个日志包

但这次我弄的时候，不知道为啥5.2.3版本一直下不起来，于是我另寻出路。

就有了下面这篇文章，就是帮助我自己记录，如果对你有帮助，那就挺好的。有说的不对的地方欢迎指正

我们也可以手动导入。
而需要导入的jar包则是，需要自己一个个下的，版本要对应好

贴一下版本对应关系
版本图片来源Spring Framework和Java版本之间的关系

一、本地导入项目的library

各版本springframework

进去之后选择你想要的版本，然后下载-dist结尾的。

下载好之后，在你的文件夹里解压，然后打开，点进libs

可以看到这么多的 （我这里默认打开软件是notepad++，所以显示是这样。这个你们随意）

然后我们将我上图中的jar包（看注释），拉到一个文件夹里。等等好导入
开始导入，按步骤一步步来 （我这里同时勾选了web项目）
注意
如果想使用aop编程，还得下aspectJweaver和aspectJ-core的jar包，比较现在spring官网推荐的就是这个

后面就是正常创建。
新项目打开后，然后我们打开file->ProjectStructure
可以看到Libary里面已经出现了刚刚我们添加的jar包。（这里也可以在Name那里改名字，在这里的jar包只能用于这个项目）

如果带web项目的话，就得把jar包添加到web项目的WEB-INF下的lib目录里，你也可以看到上图里有一个problem 1

二、global library，避免每次从本地导入（有缺点）

没错，这样子确实每次都要添加jar包，而且jar包比较多的情况 下确实比较麻烦，所以我们可以将其设置成 global library 适合于自己工作，发给别人的时候，别人就没有jar包的

然后就出现了这个在我们的Global Librarie中

然后每次新建项目后，我们啥也不用做，use library即可

目录这里的jar包就会多出我们刚刚那个

三、web项目的话，本地复制粘贴到lib中

在WEN-INF下创建classes和lib文件夹

然后将outpath改为classes

然后将lib目录作为一个jar包路径

然后我们只要直接拖动我们本地的jar包到lib目录里就可以了。
使用前两种的方法，缺点就是将项目文件夹发送给别人时，别人还得自己下载jar包

日志包

当然最后还是需要导入两个日志jar包，可以在maven仓库找到

解释包名作用

一些包的解释

包名	简单解释
spring-aop	提供对aop（切面编程）的支持
spring-aspcets	是aop的一个开源库，集成了一些aop的方法
spring-beans	对配置文件bean的创建和解析（很重要）
spring-context	对上下文（运行环境）的支持
spring-context-support	上下文中集成的一些第三方库
spring-core	spring的核心包
spring-jdbc	对数据访问的支持
spring-messaging	对消息中间件的支持，如MQ
spring-orm,spring-oxm	对第三方ORM框架的扩展和支持
spring-test	测试
spring-web	对web开发的支持
spring-webmvc	springmvc容器的支持
spring-websocket	对即时网页聊天的支持

新建第一个项目（spring web项目）注释方式

创建配置文件

idea在新建项目的时候可以勾选起来，自动创建。如果忘记了
也可以右键文件夹，创建，这样就不用写bean的头部了（这谁记得住！）
名字一般就起 applicationContext.xml （可能因为系统默认创建的就是这个名字吧，默认规则）

如果我们是默认生成的话，配置文件会在WEB-INF目录下，然后web.xml里面对于配置文件位置的写法就也是最开始设定好的。
所以如果我们想更改配置文件的位置，别忘记了更改web.xml

classpath：你的class路径;

存放位置：

1：src下面 需要在web.xml中定义如下：

	contextConfigLocation
	classpath:applicationContext.xml
< /context-param>

	


2：WEB-INF下面 需要在web.xml中定义如下：

	contextConfigLocation
	WEB-INF/applicationContext*.xml
< /context-param>

创建UserDao

public interface UserDao {
    public void say();
}

创建UserDaoImpl

package Dao.DaoImpl;
import Dao.UserDao;
import org.springframework.stereotype.Repository;
@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void say() {
        System.out.println("你最终来到了dao层的实现");
    }
}

创建UserService

public interface UserService {
    public void say();
}

创建UserServiceImpl

package Service.ServiceImpl;
import Dao.UserDao;
import Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl implements UserService {
    @Override
    public void say() {
        System.out.println("你现在正在服务层，准备调用dao层");
        userDao.say();
    }
}

创建UserController

package Controller;
import Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
    //这里添加服务层依赖
    @Autowired
    private UserService userService;
    public void say(){
        System.out.println("正在使用控制层，即将调用service层");
        userService.say();
    }
}

配置application.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
     <!--注入三个包到ioc容器当中-->
    <context:component-scan base-package="Dao.DaoImpl"></context:component-scan>
    <context:component-scan base-package="Service.ServiceImpl"></context:component-scan>
    <context:component-scan base-package="Controller"></context:component-scan>
</beans>

创建主启动类

import Controller.UserController;
import Entity.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class ApplicationStart {
    public static void main(String[] args) {
        //classpath指的是src目录下的
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:config/applicationContext.xml");
        //这个application现在相当于我们的ioc容器
        System.out.println(applicationContext);
        System.out.println();
            UserController controller1= (UserController) applicationContext.getBean("userController");
            controller1.say();
    }
}

结果

xml配置文件形式

创建User

user这个类不一定，你们可以随意

import lombok.Data;
import java.util.List;
import java.util.Set;
@Data
public class User {
    private String name;
    private String password;
    private String gender;
    private String phone;
    private String email;
    private List<String> userList;
    private Set<String> userSet;
    public List<String> getUserList() {
        return userList;
    }
    public void setUserList(List<String> userList) {
        this.userList = userList;
    }
    public Set<String> getUserSet() {
        return userSet;
    }
    public void setUserSet(Set<String> userSet) {
        this.userSet = userSet;
    }
}

配置文件是利用setter的方法，来给每个方法提供可以注入的方式

创建UserDao

public interface UserDao {
    public void say();
}

创建UserDaoImpl

package Dao.DaoImpl;
import Dao.UserDao;
public class UserDaoImpl implements UserDao {
    @Override
    public void say() {
        System.out.println("你最终来到了dao层的实现");
    }
}

创建Service层

public interface UserService {
    public void say();
}

创建ServiceImpl层

package Service.ServiceImpl;
import Dao.UserDao;
import Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
public class UserServiceImpl implements UserService {
    private UserDao userDao;
    //注意一下setUserDao这个名字，它在bean文件中的id就是去掉set后的首字母小写的userDao
    public void setUserDao(UserDao userDao) {
        this.userDao=userDao;
    }
    @Override
    public void say() {
        System.out.println("你现在正在服务层，准备调用dao层");
        userDao.say();
    }
}

创建controller层

package Controller;
import Service.UserService;

public class UserController {
    //这里添加服务层依赖
    private UserService userService;
   	//注意一下setUserDao这个名字，它在bean文件中的id就是去掉set后的首字母小写的userService
    public void setUserService(UserService userService) {
        this.userService=userService;
    }
    public void say(){
        System.out.println("正在使用控制层，即将调用service层");
        userService.say();
    }
}

编写配置文件

建议仔细看里面的注解

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

    <!--Dao-->
    <bean id="userDao" class="Dao.DaoImpl.UserDaoImpl" ></bean>


    <!--Service-->
    <bean id="userService" class="Service.ServiceImpl.UserServiceImpl">
        <!--有使用Dao的注入，所以这里要配注入property-->
        <!--ref指向userDao这个springBean。让我们userService这个bean可以引用别的bean
        value属性值是指基本类型数据的值-->
        <!--这个引用的name名字其实是setUserDao方法去掉set之后的UserDao首字母小写之后的userDao-->
        <!--即让这个方法成为注入别的bean的途径-->
        <property name="userDao" ref="userDao"></property>
    </bean>

    <!--Controller-->
    <bean id="userController" class="Controller.UserController">
        <!--同service层中需要操纵dao层一样（服务层需要操作数据层）-->
        <!--controller层中需要操纵service层一样，是不是就很像实现了解耦-->
        <!--ref里面填的是另一个bean的 id -->
        
        <property name="userService" ref="userService"></property>
    </bean>

    <!--Entity-->
    <!--方法返回值是个集合，所以里面用list，别的也有各种各样的都可以找到-->
    <bean  id="user" class="Entity.User">
        <property name="userList">
            <list>
                <value>苹果</value>
                <value>香蕉</value>
                <value>西瓜</value>
                <!--另一种写法，与上面的value相同-->
                <bean class="java.lang.String">
                    <constructor-arg name="original" value="草莓"></constructor-arg>
                </bean>
            </list>
        </property>
    </bean>
</beans>

主启动类

import Controller.UserController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ApplicationStart {
    public static void main(String[] args) {

        //classpath指的是src目录下的
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:config/applicationContext.xml");
        //这个application现在相当于我们的ioc容器
        System.out.println(applicationContext);
        System.out.println();
       
        //通过我们写的id来找bean
        UserController controller1= (UserController) applicationContext.getBean("userController");
        controller1.say();
		//找到user bean
         User user = (User) applicationContext.getBean("user");
         System.out.println(user.getUserList());

    }
}

结果