spring 入门

最新推荐文章于 2022-04-19 04:14:20 发布

Water_tu

最新推荐文章于 2022-04-19 04:14:20 发布

阅读量224

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/m0_37981386/article/details/111503851

版权

java 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1、新建文件夹learn_spring

2、在idea，File-Open ,打开文件夹learn_spring

3、新建module, 取名为spring_ioc

4、File-Project Structure,然后点击 + ,选择web,选择要添加的模块，然后修改里面的路径

工程新建完成

5、修改pom.xml, 导包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.tuy</groupId>
    <artifactId>spring_ioc</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.5.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>

    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>RELEASE</version>
        <scope>test</scope>
    </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>

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

        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

<!--        spring集成junit需要的包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        
    </dependencies>


</project>

6、在src/main/java下新建包 com.tuy.dao.impl ，com.tuy.demo , com.tuy.domain , com.tuy.service ，com.tuy.service.impl

7、编写dao层代码

package com.tuy.dao.impl;

import com.tuy.dao.UserDao;

//dao层（持久层）
public class UserDaoImpl implements UserDao {


     public UserDaoImpl() {
        System.out.println("UserDaoImpl Create....");
    }

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

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

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

package com.tuy.dao;

public interface UserDao {
    public void save();
}

9、编写service层代码

package com.tuy.service.impl;

import com.tuy.dao.UserDao;
import com.tuy.domain.User;
import com.tuy.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;
import java.util.Map;
import java.util.Properties;

//业务层
public class UserServiceImpl implements UserService {


    private UserDao userDao;
    //需要把dao注入到service，需要在配置文件 applicationContext.xml里面配置
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public UserServiceImpl()
    {
    }

    public  UserServiceImpl(UserDao userDao)
    {
        this.userDao=userDao;
    }

    public void save() {
        userDao.save();

        System.out.println(username+","+age);
        System.out.println(strList);
        System.out.println(userMap);
        System.out.println(properties);
    }

//普通属性
    private String username;
    private  int age;

    public void setUsername(String username) {
        this.username = username;
    }

    public void setAge(int age) {
        this.age = age;
    }

//集合
    private List<String> strList;
    private Map<String, User> userMap;
    private Properties properties;

    public void setStrList(List<String> strList) {
        this.strList = strList;
    }

    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }
}

package com.tuy.service;

public interface UserService {

    public void save();
}

10、编写User

package com.tuy.domain;

public class User {

    private  String name;
    private String addr;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", addr='" + addr + '\'' +
                '}';
    }
}

11、编写web层（这里是模拟的）

package com.tuy.demo;

import com.tuy.dao.UserDao;
import com.tuy.service.UserService;
import com.tuy.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

//UserController 模拟web层
public class UserController {

    public static void main(String[] args) {

        //ClassPathXmlApplicationContext 它是从类的根路径下加载配置文件 推荐使用这种, 在resource目录下
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        // 产生业务层的对象
       // UserService userService1 = (UserService) app.getBean("userService"); //app.getBean("id")
        UserService userService1 =  app.getBean(UserService.class);//不适合配置文件有多个相同id
        userService1.save();

    }


}

12、编写配置文件applicationContext.xml，需要放在resources目录下

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- dao层（持久层）   -->
    <!--  init-method指定初始化方法，destroy-method指定对象销毁方法   -->
    <!--  使用无参构造方法实例化 UserDaoImpl对象 -->
    <bean id="userDao" class="com.tuy.dao.impl.UserDaoImpl" scope="singleton" init-method="init" destroy-method="destory"></bean>

    <!-- 业务层-->
    <!--    <bean id="userService" class="com.tuy.service.impl.UserServiceImpl"  >-->
    <!--    &lt;!&ndash;  业务层依赖dao层，所以需要 把dao层对象注入到业务层      &ndash;&gt;-->
    <!--    &lt;!&ndash;第一种方法  配置依赖注入， 配置属性的名字，需要是在UserServiceImpl的setUserDao方法中的set后面的userDao(首字母改为小写),     &ndash;&gt;-->
    <!--    &lt;!&ndash;  ref的值是引用spring容器中bean的id      &ndash;&gt;-->
    <!--        <property name="userDao" ref="userDao"></property>-->
    <!--    </bean>-->

    <!--____________-->
    <!--    <bean id="userService" class="com.tuy.service.impl.UserServiceImpl"  >-->
    <!--第二种方法  通过有参构造方法来注入dao层依赖  -->
    <!--        &lt;!&ndash;  配置依赖注入， name是构造参数名字， ref的值是引用spring容器中bean的id      &ndash;&gt;-->
    <!--        &lt;!&ndash;  ref 后面是要注入(引用)的bean对象的id      &ndash;&gt;-->
    <!--        <constructor-arg name="userDao" ref="userDao"></constructor-arg>-->
    <!--    </bean>-->


    <!--____________-->
    <!--    第三种方法 依赖注入的方法： 需要引入命名空间  xmlns:p="http://www.springframework.org/schema/p" -->
    <!--  然后添加属性 p:userDao-ref="userDao"    -->
    <!--    <bean id="userService" class="com.tuy.service.impl.UserServiceImpl"  p:userDao-ref="userDao" />-->


    <bean id="user1" class="com.tuy.domain.User">
        <property name="name" value="ton"></property>
        <property name="addr" value="beijing"></property>
    </bean>
    <bean id="user2" class="com.tuy.domain.User">
        <property name="name" value="ton2"></property>
        <property name="addr" value="beijing2"></property>
    </bean>


    <bean id="userService" class="com.tuy.service.impl.UserServiceImpl"  >
        <!--  业务层依赖dao层，所以需要 把dao层对象注入到业务层      -->
        <!--第一种方法  配置依赖注入， 配置属性的名字，需要是在UserServiceImpl的setUserDao方法中的set后面的userDao(首字母改为小写),     -->
        <!--  ref的值是引用spring容器中bean的id      -->
        <property name="userDao" ref="userDao"></property>

        <!--普通属性的注入-->
        <property name="username" value="zhangsan"></property>
        <property name="age" value="18"></property>

        <!--集合性的注入-->
        <!-- List-->
        <property name="strList">
            <list>
                <!--      集合里面的数据类型是普通数据类型，用value，否则用ref          -->
                <value>hha</value>
                <value>cca</value>
            </list>
        </property>
        <!--Map-->
        <property name="userMap">
            <map>
                <entry key="user1" value-ref="user1"></entry>
                <entry key="user1" value-ref="user2"></entry>
            </map>
        </property>
        <!--Properties-->
        <property name="properties">
            <props>
                <prop key="p1">pvaaa1</prop>
                <prop key="p2">pvaaa2</prop>
                <prop key="p3">pvaaa3</prop>
            </props>
        </property>

    </bean>


    <!--    配置druid数据源   -->
<!--    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">-->
<!--        &lt;!&ndash; 配置属性，需要set方法后面的名字       &ndash;&gt;-->
<!--        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" ></property>-->
<!--        <property name="url" value="jdbc:mysql://localhost:3306/db1?serverTimezone=UTC" ></property>-->
<!--        <property name="username" value="root" ></property>-->
<!--        <property name="password" value="root" ></property>-->
<!--    </bean>-->

    <!--加载外部的配置文件 jdbc.properties-->
    <!--需要引入命名空间  xmlns:context="http://www.springframework.org/schema/context"  -->
    <!--需要引入命名空间   http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--    配置druid数据源  -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!-- 配置属性，需要set方法后面的名字  ， 值 通过外部配置文件获取      -->
        <property name="driverClassName" value="${jdbc.drive}" ></property>
        <property name="url" value="${jdbc.url}" ></property>
        <property name="username" value="${jdbc.username}" ></property>
        <property name="password" value="${jdbc.passwrod}" ></property>
    </bean>




<!--    配置组件扫描， 使用spring注解开发时候需要配置的-->
<!--   <context:component-scan base-package="com.tuy" />-->


    <!--    引入其他配置文件，可以用来分模块开发-->
    <!--<import resource="applicationContext-user.xml"/>-->


</beans>

13 创建 jdbc.properties 文件

jdbc.drive=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db1?serverTimezone=UTC
jdbc.username=root
jdbc.passwrod=root

14 新建com.tuy.test.DataSourceTest 测试类，测试通过spring 对配置文件的加载

package com.tuy.test;


import com.alibaba.druid.pool.DruidDataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import com.tuy.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ResourceBundle;

public class DataSourceTest {

    //创建c3p0数据源
    @Test
    public void test1() throws PropertyVetoException, SQLException {
         ComboPooledDataSource dataSource=new ComboPooledDataSource();
         dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
         dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/db1?serverTimezone=UTC");
         dataSource.setUser("root");
         dataSource.setPassword("root");

        Connection connection=dataSource.getConnection();
        System.out.println(connection);
        connection.close();

    }

    //创建druid数据源
    @Test
   public void  test2() throws SQLException {
       DruidDataSource dataSource=new DruidDataSource();
       dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
       dataSource.setUrl("jdbc:mysql://localhost:3306/db1?serverTimezone=UTC");
       dataSource.setUsername("root");
       dataSource.setPassword("root");

       Connection connection=dataSource.getConnection();
       System.out.println(connection);
       connection.close();

   }

//加载外部文件
   public void test3()
   {
       //读取配置文件
       ResourceBundle rb=ResourceBundle.getBundle("jdbc");  //加载类路径下的配置文件，不需要写后缀名字 ，  jdbc.properties
       String drive=rb.getString("jdbc.drive");
       String url=rb.getString("jdbc.url");
       String username=rb.getString("jdbc.username");
       String password=rb.getString("jdbc.password");
   }

   @Test
    //spring容器产生数据源对象
    public void test4() throws SQLException {

        //ClassPathXmlApplicationContext 它是从类的根路径下加载配置文件 推荐使用这种, 在resource目录下
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        // 产生业务层的对象
        // UserService userService1 = (UserService) app.getBean("userService"); //app.getBean("id")
        DataSource ds=  app.getBean(DataSource.class);//不适合配置文件有多个相同id
       Connection connection = ds.getConnection();
       System.out.println(connection);
       connection.close();

   }

}

//-------------------------------------------------------------

使用注解开发，取代xml配置文件

修改dao层的类实现文件

package com.tuy.dao.impl;

import com.tuy.dao.UserDao;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

//<bean id="userDao" class="com.tuy.dao.impl.UserDaoImpl"></bean>
//@Component("userDao")
@Repository("userDao")
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("save running...");
    }
}

修改业务层的类实现文件

package com.tuy.service.impl;

import com.tuy.dao.UserDao;
import com.tuy.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;

//<bean id="userService" class="com.tuy.service.impl.UserServiceImpl">
//@Component("userService")
@Service("userService")
//@Scope("prototype")
@Scope("singleton")
public class UserServiceImpl implements UserService {

    @Value("${jdbc.driver}")
    private String driver;

    //<property name="userDao" ref="userDao"></property>
    //@Autowired //按照数据类型从Spring容器中进行匹配的
    //@Qualifier("userDao")  //是按照id值从容器中进行匹配的 但是主要此处@Qualifier结合@Autowired一起使用
    @Resource(name="userDao") //@Resource相当于@Qualifier+@Autowired
    private UserDao userDao;

    public void save() {
        System.out.println(driver);
        userDao.save();
    }

    @PostConstruct
    public void init(){
        System.out.println("Service对象的初始化方法");
    }

    @PreDestroy
    public void destory(){
        System.out.println("Service对象的销毁方法");
    }

}

新建数据源的配置类

package com.tuy.config;


import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

//数据源的相关配置

// <context:property-placeholder location="classpath:jdbc.properties"/>    加载配置文件
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {

    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;


    @Bean("dataSource") //Spring会将当前方法的返回值以指定名称存储到Spring容器中
    public DataSource getDatsSource()
    {
        DruidDataSource dataSource=new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);

        return  dataSource;
    }
    
}

新建spring的核心配置类

package com.tuy.cofig;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

//标志该类是Spring的核心配置类
@Configuration
//<context:component-scan base-package="com.tuy"/>
@ComponentScan("com.tuy")
//<import resource=""/>
@Import({DataSourceConfiguration.class})
public class SpringCofiguration {

}

更改web层的代码

package com.itheima.web;

import com.itheima.cofig.SpringCofiguration;
import com.itheima.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserController {

    public static void main(String[] args) {
        //ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringCofiguration.class);
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }

}

//-----------------------------------------

Spring Junit 集成测试

package com.tuy.test;

import com.tuy.config.SpringConfiguration;
import com.tuy.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.sql.DataSource;
import java.sql.SQLException;

//springJunit集成测试
//spring-test

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
//@ContextConfiguration(classes = {SpringConfiguration.class})   //全注解的方式
public class SpringJunitTest {

    @Autowired                  //测试哪个就把哪个注入进来
    private UserService userService;

    @Autowired
    private DataSource dataSource;


    @Test
    public void test1() throws SQLException {
        System.out.println("---test1----");
        userService.save();
        System.out.println(dataSource.getConnection());
        System.out.println("---test1----");
    }


}

Water_tu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
spring 入门

1、新建文件夹learn_spring2、在idea，File-Open ,打开文件夹learn_spring3、新建module, 取名为spring_ioc4、File-Project Structure,然后点击 + ,选择web,选择要添加的模块，然后修改里面的路径工程新建完成5、修改pom.xml, 导包<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apa..
复制链接

扫一扫

专栏目录