Spring学习笔记03

爆炸君 @

已于 2022-10-17 18:25:22 修改

阅读量329

点赞数

文章标签： java spring servlet

于 2022-10-12 17:05:31 首次发布

本文链接：https://blog.csdn.net/qq_43480064/article/details/127286542

版权

Spring Bean 自动装配

byName、byType、constructor、default四种方式

①byName：根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean，并将其与属性自动装配。

byType：如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配；如果存在多个该类型bean，那么抛出异常，并指出不能使用byType方式进行自动装配；如果没有找到相匹配的bean，则什么事都不发生，也可以通过设置

constructor：如果发现默认的构造方法，则用 constructor 模式，否则用 byType 模式

default：默认情况下，不使用自动装配，Bean 依赖必须通过 ref 元素定义。

Spring中注入Java Collection

<list> : 该标签用来装配可重复的list值。

<set> : 该标签用来装配没有重复的set值。

<map>: 该标签可用来注入键和值可以为任何类型的键值对。

<props> : 该标签支持注入键和值都是字符串类型的键值对。

德鲁伊建立数据连接

当前的jdbc程序每次访问数据库都需要创建一个新的连接，访问完毕之后，还需要释放资源。

注意：connection的创建与销毁所消耗的资源远远大于数据库执行sql消耗的资源。基于这种实际情况，当前jdbc实现方式有如下弊端：

1.一次访问，就创建一次connection，降低程序的性能

2.connection的创建与销毁所消耗的资源远远大于数据库执行sql消耗的资源

3.频繁的连接数据会导致资源消耗过多，导致数据库宕机

思考上面的结构，大部分的时间浪费在了创建和销毁connection上。那么我们能不能实现将这些connection回收利用呢？这样我们就不需要不停的对connection进行创建和销毁了。只需要创建一次，放在指定的地方。而我们使用的时候，直接从里面拿就行了。用完放回原来的地方。不去销毁，当我再次使用的时候，去拿就行了。这样的解决方案就是我们需要的。

实现原理：一次性创建多个连接，将多个连接缓存在内存中，形成数据库连接池，如果应用程序需要操作数据库，只需要从连接池中获取一个连接，使用后，并不需要关闭连接，只需要将连接放回到连接池中。

连接池的好处：节省创建连接与释放连接的性能消耗，连接池中连接起到复用的作用，提高程序性能。

beanFactory.getBean和application.getBean的区别

@Test
public void testBeanFactory() {
    Resource resource = new ClassPathResource("applicationContext.xml");
    XmlBeanFactory beanFactory= new XmlBeanFactory(resource);
    DataSource dataSource = beanFactory.getBean(DataSource.class);
    System.out.println(dataSource);
}

BeanFactory采用懒加载的方式来注入bean，只有在调用getBean(),才对该bean加载实例化，这样我们在调用的时候才会发现配置文件出现的问题。

applicationContext则相反，它是在容器启动的时候，一次性创建所有的bean，这样容器启动的时候，我们就可以发现配置出现的问题。

其实我们使用的applicationContext接口继承了BeanFactory。可以说applicationContext本来就是一个BeanFactory。只不过他的功能要比BeanFactory要多了一点。applicationContext除了获取bean和创建bean之外还继承了其他的一些接口，相当于在BeanFactory的基础上增加了一些企业级的功能

获得bean的几种方式

1. 根据名称获取bean

这种方式的弊端在于需要强制类型转换

2. 根据名称+类型获取bean

这种方式无需强制类型转换，也解决了对于多个对象的同一种Bean获取会报错的问题。

3. 根据类型获取bean

这种方式的弊端对于多个对象的同一种类型的Bean获取会报错

三种方式相比之下，方式二是更推荐的使用方法

依赖注入

OrderDao.java

public interface OrderDao {
    public void save();
}

OrderDaoImpl.java

public class OrderDaoImpl implements OrderDao {
    public String databaseName;
    public void setDatabaseName(String databaseName) {
        this.databaseName = databaseName;
    }
    public OrderDaoImpl(String databaseName) {
        this.databaseName = databaseName;
    }
    public void save() {
        System.out.println("order dao save..."+databaseName);
    }
}

applicationContext.xml

<bean class="com.huike.dao.impl.OrderDaoImpl" id="orderDao">
    <constructor-arg name="databaseName" value="mysql"/>
    <property name="databaseName" value="sqlServer"/>
</bean>

testOrderDao

@Test
public void testOrderDao() {
    ApplicationContext ctx= new ClassPathXmlApplicationContext("applicationContext.xml");
    OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");
    orderDao.save();
}

运行结果

order dao save...sqlServer

Spring Bean 自动装配

public interface OrderService {
    public void save();
}

OrderServiceImpl.java

public class OrderServiceImpl implements OrderService {
    private OrderDao orderDao;
    public void setOrderDao(OrderDao orderDao) {
        this.orderDao = orderDao;
    }
    public OrderServiceImpl() {
    }
    public OrderServiceImpl(OrderDao orderDao) {
        this.orderDao = orderDao;
    }
    public void save() {
        System.out.println("order service save...");
        orderDao.save();
    }
}

byName

<bean class="com.huike.service.impl.OrderServiceImpl" id="orderService" autowire="byName"/>

bytype

<bean class="com.huike.service.impl.OrderServiceImpl" id="orderService" autowire="byType"/>

constructor

<bean class="com.huike.service.impl.OrderServiceImpl" id="orderService" autowire="constructor"/>

testOrderService.java

@Test
public void testOrderService() {
    ApplicationContext ctx= new ClassPathXmlApplicationContext("applicationContext.xml");
    OrderService orderService = (OrderService) ctx.getBean("orderService");
    orderService.save();
}

运行结果

order service save...
order dao save...sqlServer

Spring中注入Java Collection

List注入和Set注入

UserDao

public interface UserDao {
    public void save();
}

UserDaoImpl.java

public class UserDaoImpl implements UserDao {
    private Integer[] array;
    private List<String> list;
    private Set<Integer> set;
    private Map<String,String> map;
    private Properties properties;
    public void setArray(Integer[] array) {
        this.array = array;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setSet(Set<Integer> set) {
        this.set = set;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    public void save() {
        System.out.println("user dao save...");
        System.out.println(Arrays.toString(array));
        System.out.println(list);
        System.out.println(set);
        System.out.println(map);
        System.out.println(properties);
    }
}

<property name="array">
    <array>
        <value>1</value>
        <value>3</value>
        <value>2</value>
    </array>
</property>

<property name="list">
    <list>
        <value>a</value>
        <value>b</value>
        <value>c</value>
    </list>
</property>

testUserDao

@Test
public void testUserDao() {
    ApplicationContext ctx= new ClassPathXmlApplicationContext("applicationContext.xml");
    UserDao userDao = (UserDao) ctx.getBean("userDao");
    userDao.save();
}

运行结果

user dao save...
[1, 3, 2]
[a, b, c]
null
null
null

map和props

<property name="map">
    <map>
        <entry key="county" value="China"/>
        <entry key="province" value="Zhejiang"/>
        <entry key="city" value="Dongyang"/>
    </map>
</property>
<property name="properties">
    <props>
        <prop key="county">China</prop>
        <prop key="province">Zhejiang</prop>
        <prop key="city">Dongyang</prop>
    </props>
</property>

运行结果

user dao save...
[1, 3, 2]
[a, b, c]
null
{county=China, province=Zhejiang, city=Dongyang}
{province=Zhejiang, county=China, city=Dongyang}

建立数据连接

引入依赖

<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.2.13</version>
</dependency>

applicationContext.xml

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

testDruidDataSource

@Test
public void testDruidDataSource() {
    ApplicationContext ctx= new ClassPathXmlApplicationContext("applicationContext.xml");
    DataSource dataSource = (DataSource) ctx.getBean("dataSource");
    System.out.println(dataSource);
}

使用properties文件配置数据库

jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/user?useUnicode=true&useJDBCCompliantTimezoneShift=true;useLegacyDatetimeCode=false&serverTimezone=GMT%2B8&characterEncoding=UTF8
jdbc.username=root
jdbc.password=password

applicationContext.xml

<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
    <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>

BeanFactory

@Test
    public void testBeanFactory() {
        Resource resource = new ClassPathResource("applicationContext.xml");
        XmlBeanFactory beanFactory= new XmlBeanFactory(resource);
        DataSource dataSource = beanFactory.getBean(DataSource.class);
        System.out.println(dataSource);
    }

运行结果

{
    CreateTime:"2022-10-12 15:32:55",
    ActiveCount:0,
    PoolingCount:0,
    CreateCount:0,
    DestroyCount:0,
    CloseCount:0,
    ConnectCount:0,
    Connections:[
    ]
}

获得bean的几种方式

BookServiceImpl.java

public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public BookServiceImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }
    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }
}

applicationContext.xml

<bean class="com.huike.dao.impl.BookDaoImpl" id="bookDao">
    <constructor-arg value="mysql" type="java.lang.String"/>
    <constructor-arg value="10"/>
</bean>

testBookDao

    @Test
    public void testBookDao() {
        ApplicationContext ctx= new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据类型获取bean
        // 1. 根据名称获取bean
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        // 2. 根据名称+类型获取bean
        BookDao bookDao1 = ctx.getBean("bookDao", BookDao.class);
        // 3. 根据类型获取bean
        BookDao bookDao2 = ctx.getBean(BookDao.class);
        bookDao2.save();
//        bookDao1.save();
//        bookDao.save();
    }

运行结果