Java随笔（一）

最新推荐文章于 2024-07-05 15:43:03 发布

Freddie•方

最新推荐文章于 2024-07-05 15:43:03 发布

阅读量218

点赞数

分类专栏： JavaSE 文章标签： JavaWeb随笔

本文链接：https://blog.csdn.net/qq_32794741/article/details/99680372

版权

JavaSE 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Java随笔（一）

零碎知识点

Socket

套接字（socket）是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序将I/O插入到网络中，并与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合。

所谓套接字，实际上是一个通信端点，每个套接字都有一个套接字序号，包括主机的IP地址与一个16位的主机端口号，即形如（主机IP地址：端口号）。例如，如果IP地址是210.37.145.1，而端口号是23，那么得到套接字就是（210.37.145.1：23）。

强转string和toString的区别？

toString返回该Object对象的字符串，toString()方法返回的是这个对象的字符串表示，就像是这个对象的名字一样，任何对象都可以有自己的名字。

string是将不同的数据类型强制转换为string类型，不是所有的都能转换。

解决不能注入bean

使用@Autowired的required属性（NoSuchBeanDefinitionException的异常）

如果容器中没有一个和标注变量类型匹配的Bean，Spring容器启动时将报NoSuchBeanDefinitionException的异常。如果希望Spring即使找不到匹配的Bean完成注入也不用抛出异常，那么可以使用==@Autowired(required=false)==进行标注，默认情况下，@Autowired的required属性的值为true，即要求一定要找到匹配的Bean，否则将报异常。

如果容器中有一个以上匹配的Bean时，则可以通过@Qualifier注解限定Bean的名称，出现两个相同类型的bean注入需要加一个@Qualifier注解

Idea查看源码

如果是看接口的底层,就用ctrl+alt
如果是看其他的底层,就双击锁定,然后两下shift即可.
如果看继承树,ctrl+h

DOS关闭端口

$[外链图片转存失败(img-boYXpi6l-1565943141400)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1563586964640.png)]$

dem4j

DOM4J是dom4j.org出品的一个开源XML解析包,Dom4j是一个易用的、开源的库，用于XML，XPath和XSLT。它应用于Java平台，采用了Java集合框架并完全支持DOM，SAX和JAXP。

基本数据类型和包装类

基本数据类型
- 优点：
  1，用于计算是效率高；
  2，值比较方便，使用 == 就可以了。
- 缺点：
  1，从数据库中查出值时可能会有null，基本类型接收NULL值有NPE风险（java.lang.NullPointerException NPE 空值异常）；
  
  2，默认值和NULL值不能传达同一种信息，例如考试分数字段，如果使用Integer类型，那么没有参加考试的分数可以设置为null；如果用int类型，那么分数值都是0，无法没有参加考试还是参加考试得0分。
包装类
- 所有基本类型封装对象所占内存的大小都是16字节，但是还是有区别，比如：
  Integer对象虽然占用了16个字节的内存，但是只是利用了Object所占内存(8个字节)+int所占内存(4个字节)=12字节，还有4个字节根本没有被使用。
- 优点：
  1，可以存放null，从数据库中查出值时可能会有null；
- 缺点：
  1，不能使用 == 比较相等。
  2，占用更多的内存空间；
- 总结
  1，所有POJO类属性必须使用包装数据类型；
  
  2，所有的局部变量推荐使用基本数据类型。

封装

封装
- 将不需要对外提供的内容都隐藏起来。
- 把属性都隐藏，提供公共方法对其访问。
面向对象
- 将数据与行为分离，也就是java的面向对象的概念。
- 对象就是属性+行为，封装就是把对象的私有属性封装起来，只有通过自己公开的行为去改变（获得）对象内部的私有属性信息，而那些public的方法正是面向其他对象的接口，只有通过接口去改变（获得）对象的私有属性。

反射

反射是：指程序可以访问、检测和修改它本身状态或行为的一种能力

反射是一种能力，所以给的定义就是说明了它能干嘛。

我们平时用反射主要做：

获取类型的相关信息
动态调用方法
动态构造对象
从程序集中获得类型

零碎知识点

instanceof:

“a instanceof MyClass”,其实可以理解为左边引用a所对应的class是否可以与右边myClass互相进行转换.那再思考下，什么情况下类可以进行相互转换呢?在java中有两种情况，一种是接口实现，另一种是继承，根据这两种情况，即A的super和interface路径上是否存在MyClass,这样就可以很容易实现这个instanceof的功能了，在本人的简易jvm实现中已经实现了这个功能。

工具网址：

$[外链图片转存失败(img-CCHLVzPd-1565943141407)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1563506399057.png)]$

WEB-INF 是安全目录，不能直接访问

将配置文件读取为字节输入流：类名.class.getClassLoader().getResourceAsStream(“jdbc.properties”);

Ctrl+Alt+F 创建成员变量

secureCRT快捷键：Alt+P 传输文件到Linux中。

Ctrl+Alt+V 生成返回对象

Spring

beans里面的bean放置顺序会影响执行代码的顺序

FileSystemXmlApplicationContext方式创建spring容器需要传入绝对路径名

final、finally、finalize 的区别

1）final：用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，被其修饰的类不可继承。
2）finally：异常处理语句结构的一部分，表示总是执行。
3）finalize：Object 类的一个方法，在垃圾回收器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。该方法更像是一个对象生命周期的临终方法，当该方法被系统调用则代表该对象即将“死亡”，但是需要注意的是，我们主动行为上去调用该方法并不会导致该对象“死亡”，这是一个被动的方法（其实就是回调方法），不需要我们调用。

方法重写与重载的区别

一、方法重写(0veriding)： 父类方法的参数列表必须完全与被子类重写的方法的参数列表相同

在Java程序中，类的继承关系可以产生一个子类，子类继承父类，它具备了父类所有的特征，继承了父类所有的方法和变量。

子类可以定义新的特征，当子类需要修改父类的一些方法进行扩展，增大功能，程序设计者常常把这样的一种操作方法称为重写，也叫称为覆写或覆盖。

重写体现了Java优越性，重写是建立在继承关系上，它使语言结构更加丰富。在Java中的继承中，子类既可以隐藏和访问父类的方法，也可以覆盖继承父类的方法。

在Java中覆盖继承父类的方法就是通过方法的重写来实现的。所谓方法的重写是指子类中的方法与父类中继承的方法有完全相同的返回值类型、方法名、参数个数以及参数类型。

这样，就可以实现对父类方法的覆盖。如果子类将父类中的方法重写了，调用的时候肯定是调用被重写过的方法，那么如果现在一定要调用父类中的方法该怎么办呢?

此时，通过使用super关键就可以实现这个功能，super关键字可以从子类访问父类中的内容，如果要访问被重写过的方法，使用“super.方法名(参数列表)”的形式调用。

如果要使用super关键字不一定非要在方法重写之后使用，也可以明确地表示某个方法是从父类中继承而来的。使用super只是更加明确的说，要从父类中查找，就不在子类查找了。

二、重写规则
在重写方法时，需要遵循以下的规则：
(一) 父类方法的参数列表必须完全与被子类重写的方法的参数列表相同，否则不能称其为重写而是重载。
(二) 父类的返回类型必须与被子类重写的方法返回类型相同，否则不能称其为重写而是重载。…
(三) ==Java中规定，被子类重写的方法不能拥有比父类方法更加严格的访问权限。==编写过Java程序的人就知道，

父类中的方法并不是在任何情况下都可以重写的，当父类中方法的访问权限修饰符为private时，该方法只能被自己的类访问，

不能被外部的类访问，在子类是不能被重写的。如果定义父类的方法为public，在子类定义为private，程序运行时就会报错。

(四) 由于父类的访问权限修饰符的限制一定要大于被子类重写方法的访问权限修饰符，而private权限最小。

所以如果某一个方法在父类中的访问权限是private，那么就不能在子类中对其进行重写。如果重新定义，也只是定义了一个新的方法，不会达到重写的效果。
(五) 在继承过程中如果父类当中的方法抛出异常，那么在子类中重写父类的该方法时，也要抛出异常，

而且抛出的异常不能多于父类中抛出的异常(可以等于父类中抛出的异常)。换句话说，重写方法一定不能抛出新的检查异常，

或者比被重写方法声明更加宽泛的检查型异常。例如，父类的一个方法申明了一个检查异常IOException，在重写这个方法时就不能抛出Exception，

只能抛出IOException的子类异常，可以抛出非检查异常。同样的道理，如果子类中创建了一个成员变量，

而该变量和父类中的一个变量名称相同，称作变量重写或属性覆盖。但是此概念一般很少有人去研究它，因为意义不大。

**三、方法重载(Overloading)：**方法重载是让类以统一的方式处理不同类型数据的一种手段

方法重载是让类以统一的方式处理不同类型数据的一种手段。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法，这就是多态性。
所谓方法重载是指在一个类中，多个方法的方法名相同，但是参数列表不同。参数列表不同指的是参数个数、参数类型或者参数的顺序不同。

方法的重载在实际应用中也会经常用到。不仅是一般的方法，构造方法也可以重载。

在方法重载时，方法之间需要存在一定的联系，因为这样可以提高程序的可读性，一般只重载功能相似的方法。

重载是指我们可以定义一些名称相同的方法，通过定义不同的参数来区分这些方法，然后再调用时，Java虚拟机就会根据不同的参数列表来选择合适的方法执行

。也就是说，当一个重载方法被调用时，Java用参数的类型或个数来决定实际调用的重载方法。因此，每个重载方法的参数的类型或个数必须是不同。

虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。

当Java调用一个重载方法是，参数与调用参数匹配的方法被执行。在使用重载要注意以下的几点:
1.在使用重载时只能通过不同的参数列表，必须具有不同的参数列表。

2.不能通过访问权限、返回类型、抛出的异常进行重载。
3.方法的异常类型和数目不会对重载造成影响。
4.可以有不同的返回类型，只要参数列表不同就可以了。
5.可以有不同的访问修饰符。

6.可以抛出不同的异常。

四、方法重写与方法重载的区别

软编码和硬编码如何区分软编码：使用CPU进行编码

硬编码：使用非CPU进行编码，如显卡GPU、专用的DSP、FPGA、ASIC芯片等

软编码和硬编码比较
软编码：实现直接、简单，参数调整方便，升级易，但CPU负载重，性能较硬编码低，低码率下质量通常比硬编码要好一点

硬编码：性能高，低码率下通常质量低于软编码器，但部分产品在GPU硬件平台移植了优秀的软编码算法（如X264）的，质量基本等同于软编码

statement对象的详述

Statement 对象用于将 SQL 语句发送到数据库中。实际上有三种 Statement 对象，它们都作为在给定连接上执行 SQL 语句的包容器：Statement、PreparedStatement（它从 Statement 继承而来）和 CallableStatement（它从 PreparedStatement 继承而来）。它们都专用于发送特定类型的 SQL 语句： Statement 对象用于执行不带参数的简单 SQL 语句；PreparedStatement 对象用于执行带或不带 IN 参数的预编译 SQL 语句；CallableStatement 对象用于执行对数据库已存储过程的调用。
Statement 接口提供了执行语句和获取结果的基本方法。PreparedStatement 接口添加了处理 IN 参数的方法；而 CallableStatement 添加了处理 OUT 参数的方法。
有些 DBMS 将已存储过程中的每条语句视为独立的语句；而另外一些则将整个过程视为一个复合语句。在启用自动提交时，这种差别就变得非常重要，因为它影响什么时候调用 commit 方法。在前一种情况中，每条语句单独提交；在后一种情况中，所有语句同时提交。
Statement 对象将由 Java 垃圾收集程序自动关闭。而作为一种好的编程风格，应在不需要 Statement对象时显式地关闭它们。这将立即释放 DBMS 资源，有助于避免潜在的内存问题。
Statement 对象用于执行不带参数的简单 SQL 语句；

PreparedStatement 对象用于执行带或不带 IN参数的预编译 SQL 语句；

CallableStatement 对象用于执行对数据库已存储过程的调用。

对象造型

所谓对象造型就是Java对象间的类型转换。

Java对象间的造型分为：自动造型和强制造型。

//Student类继承与Person类
Person p = new Student();//自动造型,向上转型
Student s = (Student)p;//强制造型，向下转型

对象的造型只用在有继承关系或接口实现的对象之间（即多态）

SSH

spring：用于进行解耦和整合的框架

Struts2：表现层框架

hibernate：持久层框架

SSM

spring:用于进行解耦和整合的框架

springMVC：表现层框架

mybatis：持久层框架

程序架构的简介

单体架构：所有的功能都写在同一个项目中，就会造成代码的冗余、耦合度高的问题。

垂直架构：

微服务架构：将各个功能模块做成服务的形式、这样减少了代码的冗余，降低程序的耦合度。

catalina

catalina是Tomcat服务器使用的Apache实现的servlet容器的名字。

Tomcat的核心分为3个核心部分：

（1）Web容器–处理静态页面；

（2）catalina–一个servlet容器–处理servlet；

（3）JSP容器–把jsp页面翻译成一般的servlet。

queryForObject，查询对象

域对象？？

根据有作用范围由小到大：
page(jsp有效)------》page域指的是pageContext.
request(一次请求)---》request域request HttpServletContext
session(一次会话)---》session域session HttpSession
application(当前web应用)---》application域指的是application  ServletContext；
之所以他们是域对象，原因是他们都内置了map集合，都有setAttribute和getAttribute方法。
一、PageContext域
1.生命周期：当对JSP的请求开始，当相应结束时销毁。
           jsp页面被执行，声明周期开始；
           jsp页面执行完毕，声明周期结束；
2.作用范围：整个JSP页面，是四大作用域中最小的一个。
3.作用：
　　　（1）获取其它八大隐式对象，可以认为是一个入口对象。 
　　　（2）获取其所有域中的数据    
pageContext　　操作所有域中属性的方法    
public java.lang.Object getAttribute(java.lang.String name,int scope)      　　　　　　　　　　　　　
public void setAttribute(java.lang.String name, java.lang.Object value,int scope)    
public void removeAttribute(java.lang.String name,int scope)          
pageContext 中代表域的常量    
　　　PageContext.APPLICATION_SCOPE    
　　　PageContext.SESSION_SCOPE    
　　　PageContext.REQUEST_SCOPE    
　　　PageContext.PAGE_SCOPE          
findAttribute方法,在四大域中搜寻属性，搜寻的顺序是page域、request域、session域、application域，从小域到大域开始搜索，如果搜索到就直接获取该值，如果所有域中都找不到，返回一个null(与el表达式不同，此处返回null，对网页是不友好的)       
　　　（3）跳转到其他资源      其身上提供了forward和include方法，简化重定向和转发的操作
二、Request域
1.生命周期：
    在Service方法调用前由服务器创建，传入service方法。整个请求结束，request生命结束。
    用户发送一个请求，开始，服务器返回响应，请求结束，生命周期结束；
2.作用范围：整个请求链（请求转发也存在）
3.作用：在整个请求链中共享数据，经常用到：在servlet中处理好的数据交给JSP显示，此时参数就可以放在Request域中。
三、HttpSession 域
1.生命周期：
    在第一次调用request.getSession()方法时，服务器会检查是否已经有对应的session，如果没有就在内存中创建一个session并返回。
（1）当一段时间内session没有被使用（默认为30分钟），则服务器会销毁该session。
（2）如果服务器非正常关闭，没有到期的session也会跟着销毁。
（3）如果调用session提供的invalidate()，可以立即销毁session。
用户打开浏览器访问，创建session（开始），session超时或者被声明失效，该对象生命周期结束；
2.作用范围：一次会话。
HttpSession 在服务器中，为浏览器创建独一无二的内存空间，在其中保存会话相关的信息
注意：服务器正常关闭，再启动，Session对象会进行钝化和活化操作。同时如果服务器钝化的时间在session 默认销毁时间之内， 则活化后session还是存在的。否则Session不存在。  如果JavaBean 数据在session钝化时，没有实现Serializable 则当Session活化时，会消失。
 
四、ServletContext
1.生命周期：
    当WEB应用被加载进容器创建代表整个WEB应用的ServletContext对象；
    当服务器关闭或WEB应用被移除时，ServletContext对象跟着被销毁。
2.作用范围：整个WEB应用。
3、作用： 
a)在不同Servlet 之间转发  
this.getServletContext().getRequestDispatcher("/servlet/Demo10Servlet").forward(request,response); 
方法执行结束，service就会返回到服务器，再有服务器去调用目标servlet，其中request会重新创建，并将之前的request的数据拷贝进去。    
b)读取资源文件。
1、由于相对路径默认相对的是java虚拟机启动的目录，所以我们直接写相对路径将会是相对于tomcat/bin目录，所以是拿不到资源的。如果写成绝对路径，当项目发布到其他环境时，绝对路径就错了。  
为了解决这个问题ServletContext提供了：
this.getServletContext().getRealPath("/1.properties")，给进一个资源的虚拟路径，将会返回该资源在当前环境下的真实路径。　　　　　　　　
this.getServletContext().getResourceAsStream("/1.properties")，给一个资源的虚拟路径返回到该资源真实路径的流。  
2、当在非servlet下获取资源文件时，就没有ServletContext对象用了，此时只能用类加载器   
classLoader.getResourceAsStream("../../1.properties")，此方法利用类加载器直接将资源加载到内存中，有更新延迟的问题，以及如果文件太大，占用内存过大。   
classLoader.getResource("../1.properties").getPath()，直接返回资源的真实路径，没有更新延迟的问题。
cookie存在于一次对话中，对话关闭就不存在了，浏览器关闭cookie也就不存在了

面向对象的设计思想，六大基本原则：

1、单一职责原则

（一个类完成一个功能，分

模块，分三层：
web层：表现层负责与客

户端进行交互（1、2、3、）；
service层：业务层负责处理请求、处理业务逻辑；
dao层：持久层/数据访问层负责跟数据库增删改查】）。

src下的三层架构

1、Servlet需要完成的事

表现层  负责与客户端进行交互

1、获取请求参数

2、校验用户名和密码，调用service层的方法，处理请求

3、判断是否登录成功

2、service用于调用dao层的方法

业务层  负责处理请求、处理业务逻辑

1、调用dao层的XXX方法保存用户信息

2、调用dao层的XXX方法，根据传递的参数（1，2）进行查找用户

3、dao层

持久层/数据访问层  负责跟数据库交互

调用JDBCTemplate方法操作数据库，进行增删改查

4、domain方JavaBean类

5、Utils用于存放工具类

spring话题

@Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能.

spring中的@ComponentScan（启动容器注解）、@ComponentScan（自动扫描注解）、@Import

@Configuation等价于

@Bean等价于

@ComponentScan等价于<context:component-scan base-package=“com.dxz.demo”/>

@Import:在没有使用@Component、@service、@controller和@Repository注解是就需要@Import注解来将没有注入bean的类注入

一、单独使用

1、相当于beans标签，例：

@Configuration
public class TestConfiguration {
    public TestConfiguration() {
    	System.out.println("TestConfiguration容器启动初始化。。。");
	}
}

相当于：

?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" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:util="http://www.springframework.org/schema/util" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd" default-lazy-init="false">


</beans>

//主方法进行测试：

ackage com.dxz.demo.configuration;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

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

// @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);

// 如果加载spring-context.xml文件：
// ApplicationContext context = new
// ClassPathXmlApplicationContext("spring-context.xml");
}
}

2、@Configuration启动容器+@Bean注册Bean，@Bean下管理bean的生命周期，@Bean标注在方法上(返回某个实例的方法)，等价于spring的xml配置文件中的<bean>，作用为：注册bean对象

二、组合使用

1、
@Configuration
@ImportResource("classpath:applicationContext-configuration.xml")
    
ackage com.dxz.demo.configuration2;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

@Configuration
@ImportResource("classpath:applicationContext-configuration.xml")
public class WebConfig {
}

bean类：

ackage com.dxz.demo.configuration2;

public class TestBean2 {
private String username;
private String url;
private String password;

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

public String toString() {
return "TestBean2 username:" + this.username + ",url:" + this.url + ",password:" + this.password;
}

public void start() {
System.out.println("TestBean2 初始化。。。");
}

public void cleanUp() {
System.out.println("TestBean2 销毁。。。");
}
}

测试类：

ackage com.dxz.demo.configuration2;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

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

// @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);

// 如果加载spring-context.xml文件：
// ApplicationContext context = new
// ClassPathXmlApplicationContext("spring-context.xml");

// 获取bean
TestBean2 tb = (TestBean2) context.getBean("testBean2");
tb.sayHello();
}
}



2、
@Configuration
@ImportResource("classpath:applicationContext-configuration.xml")
@Import(TestConfiguration.class)
ackage com.dxz.demo.configuration2;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;

import com.dxz.demo.configuration.TestConfiguration;

@Configuration
@ImportResource("classpath:applicationContext-configuration.xml")
@Import(TestConfiguration.class)
public class WebConfig {
}

测试类：

ackage com.dxz.demo.configuration2;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.dxz.demo.configuration.TestBean;

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

// @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);

// 如果加载spring-context.xml文件：
// ApplicationContext context = new
// ClassPathXmlApplicationContext("spring-context.xml");

// 获取bean
TestBean2 tb2 = (TestBean2) context.getBean("testBean2");
tb2.sayHello();

TestBean tb = (TestBean) context.getBean("testBean");
tb.sayHello();
}
}



3、
ackage com.dxz.demo.configuration3;

import org.springframework.stereotype.Component;

@Component
public class TestBean {

private String username;
private String url;
private String password;

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

public String toString() {
return "username:" + this.username + ",url:" + this.url + ",password:" + this.password;
}

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

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

 

ackage com.dxz.demo.configuration3;

public class DataSource {

private String dbUser;
private String dbPass;
public String getDbUser() {
return dbUser;
}
public void setDbUser(String dbUser) {
this.dbUser = dbUser;
}
public String getDbPass() {
return dbPass;
}
public void setDbPass(String dbPass) {
this.dbPass = dbPass;
}
@Override
public String toString() {
return "DataSource [dbUser=" + dbUser + ", dbPass=" + dbPass + "]";
}
}

配置类：

ackage com.dxz.demo.configuration3;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.dxz.demo.configuration3")
public class TestConfiguration {
public TestConfiguration() {
System.out.println("TestConfiguration容器启动初始化。。。");
}

@Configuration
static class DatabaseConfig {
@Bean
DataSource dataSource() {
return new DataSource();
}
}
}

启动类：

ackage com.dxz.demo.configuration3;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

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

// @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContexts
ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);

//bean
TestBean tb = (TestBean) context.getBean("testBean");
tb.sayHello();

DataSource ds = (DataSource) context.getBean("dataSource");
System.out.println(ds);
}
}

设计模式

单例模式

代理

$[外链图片转存失败(img-COgYjDVy-1565943141419)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1562638288321.png)]$

urn new DataSource();
}
}
}

启动类：

ackage com.dxz.demo.configuration3;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

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

// @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContexts
ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);

//bean
TestBean tb = (TestBean) context.getBean(“testBean”);
tb.sayHello();

DataSource ds = (DataSource) context.getBean(“dataSource”);
System.out.println(ds);
}
}