1
2
3
4
3. Vòng đời @BeanAnnotation @Bean cũng hỗ trợ chức năng Initialization và Destruction giống như trong Spring XML là init-method và destroy-method. Spring Ioc là một cơ chế để đạt được tư tưởng loose-coupling trong Objects dependencies. Đây là tư tưởng mà các thành phần làm việc độc lập với nhau. Dể đạt được tư tưởng này cũng như việc binding các object một cách linh hoạt tại runtime, Objects dependencies được inject bởi các object ghép khác. Spring IoC container là chương trình cho phép inject dependency vào một object và khiến cho sẵn sàng để được sử dụng. Spring IoC container classes là thành phần của org.springframework.beans và org.springframework.context. Spring IoC container cung cấp cho chúng ta rất nhiều cách để decouple các đối tượng dependencies. BeanFactory là root interface của Spring IoC container. ApplicationContext là child interface của BeanFactory interface - cung cấp cách chức năng Spring AOP, i18n v.v... Một trong số các interfaces con hữu ích của ApplicationContext chính là ConfigurableApplicationContext và WebApplicationContext. Spring Framework cung cấp rất nhiều các class implement ApplicationContext mà chúng ta có thể sử dụng để có thể lấy được spring context và Spring Bean. Một vài implementations rất hữu ích của ApplicationContext implementations mà chúng ta sẽ hay dùng : AnnotationConfigApplicationContext: Nếu chúng ta sử dụng Spring trong các ứng dụng java độc lập và sử dụng annotations cho việc cấu hình, thì chúng ta có thể sử dụng nó để khởi tạo container và lấy các đối tượng bean.ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml"); MyService app = context.getBean(MyService.class); In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. Nói một cách đơn giản, bean là những module chính của chương trình, được tạo ra và quản lý bởi Spring IoC container. Các bean có thể phụ thuộc lẫn nhau, như ví dụ về ApplicationContext context = SpringApplication.run(Application.class, args);
8, ApplicationContext context = SpringApplication.run(Application.class, args);
9 và // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
0 từ đầu series tới giờ. Sự phụ thuộc này được mô tả cho IoC biết nhờ cơ chế Dependency injection.Lúc này chỉ cần biết đơn giản nhất là dùng // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
1 lên class là class đó là một bean. Bảo mật ứng dụng Java web bởi Spring Security Cách sử dụng properties trong tập tin cấu hình của Spring Xem thêm nhiều việc làm Spring lương cao trên TopDev 2. ApplicationContext là gì?ApplicationContext là khái niệm Spring Boot dùng để chỉ Spring IoC container, tương tự như bean là đại diện cho các dependency. Ngoài ra bạn có thể sẽ nghe nói về BeanFactory. Nó cũng đại loại như ApplicationContext, đại diện cho Spring IoC container nhưng ở mức cơ bản. ApplicationContext thì ở mức cao hơn, cung cấp nhiều tính năng hơn BeanFactory như i18n, resolving messages, publishing events,… Khi ứng dụng Spring chạy, Spring IoC container sẽ quét toàn bộ packages, tìm ra các bean và đưa vào ApplicationContext. Cơ chế đó là Component scan. Cách lấy bean ra từ ContextTất nhiên trước khi lấy bean ra từ context thì phải có context rồi. Câu hỏi đặt ra là biến context ở đâu? Đó là ngay dòng bắt đầu chương trình Spring Boot. Câu lệnh sau. @SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
Dòng method // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
2 sẽ return về một object // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
3 interface, đại diện cho IoC container.ApplicationContext context = SpringApplication.run(Application.class, args);
Chúng ta có thể lấy ra bean từ đây, dùng method // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
4.// Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
3. Kĩ thuật inject bean vào bean khácVí dụ bạn có hai bean là ApplicationContext context = SpringApplication.run(Application.class, args);
8 và ApplicationContext context = SpringApplication.run(Application.class, args);
9 (như ví dụ từ đầu series tới giờ). Và ApplicationContext context = SpringApplication.run(Application.class, args);
8 thì phụ thuộc vào ApplicationContext context = SpringApplication.run(Application.class, args);
9, do đó theo Dependency injection thì chúng ta cần inject ApplicationContext context = SpringApplication.run(Application.class, args);
9 vào trong ApplicationContext context = SpringApplication.run(Application.class, args);
8.3.1. Sử dụng // Annotation chỉ đánh dấu lên class
public interface Engine {
void run();
}
1Chúng ta sử dụng annotation // Annotation chỉ đánh dấu lên class
public interface Engine {
void run();
}
1 để báo cho Spring biết tự động tìm và inject bean phù hợp vào vị trí đặt annotation. Ví dụ.// Annotation chỉ đánh dấu lên class
public interface Engine {
void run();
}
@Component
public class ChinaEngine implements Engine {
@Override
public void run() {}
}
@Component
public class Car {
// Báo cho Spring tìm bean nào phù hợp với Engine interface
// Và có một bean phù hợp là ChinaEngine
// Nó tương đương với = new ChinaEngine()
@Autowired
private final Engine engine;
}
Cách dùng // Annotation chỉ đánh dấu lên class
public interface Engine {
void run();
}
1 trên field là không được khuyến khích, do nó sử dụng Java reflection để inject. Chúng ta nên cân nhắc đổi qua dùng inject theo kiểu constructor hoặc setter.3.2. Inject qua constructor hoặc setterCode inject theo kiểu constructor-based nên dùng khi các module là bắt buộc. Khi đó Spring Boot khi tạo bean (cũng chỉ là tạo object, gọi constructor thôi) thì sẽ đưa các phụ thuộc vào constructor khi gọi. Ví dụ class ApplicationContext context = SpringApplication.run(Application.class, args);
8 đã được sửa lại để inject ApplicationContext context = SpringApplication.run(Application.class, args);
9 vào qua constructor.@Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
Hoặc dùng kiểu setter-based như sau. Spring Boot sau khi tạo xong bean ApplicationContext context = SpringApplication.run(Application.class, args);
8 sẽ gọi thêm method // Annotation chỉ đánh dấu lên class
public interface Engine {
void run();
}
7 sau đó.@Component
public class Car {
private final Engine engine;
// Thêm @Required để setter luôn được gọi để inject
@Required
public void setEngine(Engine engine) {
this.engine = engine;
}
}
Cách dùng setter để inject thường dùng trong trường hợp phụ thuộc vòng, module A phụ thuộc vào B và ngược lại. Do đó, nếu cả hai đều sử dụng constructor based injection thì Spring Boot sẽ không biết nên tạo bean nào trước. Vì thế, giải pháp là một bean sẽ dùng constructor, một bean dùng setter như trên. 4. Khi Spring Boot không biết chọn bean nào?4.1. Khi tìm thấy nhiều bean phù hợpCũng lấy ví dụ trên, nếu chúng ta tạo thêm class // Annotation chỉ đánh dấu lên class
public interface Engine {
void run();
}
8 có chức năng tương tự // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
0.@Component
public class VNEngine implements Engine {
@Override
public void run() {}
}
Thì Spring Boot sẽ báo lỗi như sau (báo khi chạy và cả trong IDE nữa. Có thể hiểu do Spring Boot đã tìm thấy hai bean phù hợp để inject vào ApplicationContext context = SpringApplication.run(Application.class, args);
8. Do cả hai // Annotation chỉ đánh dấu lên class
public interface Engine {
void run();
}
8 và // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
0 đều implements ApplicationContext context = SpringApplication.run(Application.class, args);
9, mà ApplicationContext context = SpringApplication.run(Application.class, args);
8 cần ApplicationContext context = SpringApplication.run(Application.class, args);
9 nên không biết nên chọn cái nào.4.2. Giải phápCó hai cách giải quyết vấn đề này. Thứ nhất là dùng @Component
public class ChinaEngine implements Engine {
@Override
public void run() {}
}
6 đánh dấu lên một bean. Khi đó bean này sẽ được ưu tiên chọn hơn, trong trường hợp có nhiều bean phù hợp trong context.@Component
@Primary
public class VNEngine implements Engine {
...
}
Cách 2 là chỉ định rõ tên bean (tên class) cụ thể được inject bằng @Component
public class ChinaEngine implements Engine {
@Override
public void run() {}
}
7.ApplicationContext context = SpringApplication.run(Application.class, args);
0Đối với constructor hay setter based cũng tương tự, chỉ cần có @Component
public class ChinaEngine implements Engine {
@Override
public void run() {}
}
7 trước tên field cần inject vào là được.3. Spring Bean Life Cycle1.1. Bean life cycleTrong bài trước chúng ta đã tìm hiểu sơ lược về bean là gì, hôm nay chúng ta sẽ đi sâu hơn tí nhé. Vòng đời (life cycle) của bean được hiểu là từ khi bean được tạo ra cho tới khi chết đi, sẽ có những sự kiện (event) khác nhau xảy ra. Về vòng đời của bean có thể mô tả bởi sơ đồ sau. Nhìn có vẻ dài và khó hiểu, nhưng đại loại sẽ gồm các bước sau: Sau đó bean sẽ sẵn sàng hoạt động. Nếu sau đó bean không dùng nữa thì nó sẽ được hủy: 1.2. @Component
public class ChinaEngine implements Engine {
@Override
public void run() {}
}
9 và @Component
public class Car {
// Báo cho Spring tìm bean nào phù hợp với Engine interface
// Và có một bean phù hợp là ChinaEngine
// Nó tương đương với = new ChinaEngine()
@Autowired
private final Engine engine;
}
0Đây là hai event khá quan trọng với bean, bạn có thể hook một method vào đó để thực thi khi event xảy ra: @Component
public class Car {
// Báo cho Spring tìm bean nào phù hợp với Engine interface
// Và có một bean phù hợp là ChinaEngine
// Nó tương đương với = new ChinaEngine()
@Autowired
private final Engine engine;
}
3 là sau khi bean đã khởi tạo xong@Component
public class Car {
// Báo cho Spring tìm bean nào phù hợp với Engine interface
// Và có một bean phù hợp là ChinaEngine
// Nó tương đương với = new ChinaEngine()
@Autowired
private final Engine engine;
}
0 là trước khi bean bị phá hủy
Chúng ta dùng hai annotation trên đánh dấu lên method nào đó, method đó sẽ được tự động gọi khi sự kiện bean xảy ra. ApplicationContext context = SpringApplication.run(Application.class, args);
1Như code ví dụ trên, mình gắn @Component
public class Car {
// Báo cho Spring tìm bean nào phù hợp với Engine interface
// Và có một bean phù hợp là ChinaEngine
// Nó tương đương với = new ChinaEngine()
@Autowired
private final Engine engine;
}
3 cho method @Component
public class Car {
// Báo cho Spring tìm bean nào phù hợp với Engine interface
// Và có một bean phù hợp là ChinaEngine
// Nó tương đương với = new ChinaEngine()
@Autowired
private final Engine engine;
}
6. Method này được gọi khi bean ApplicationContext context = SpringApplication.run(Application.class, args);
8 được tạo ra và khởi tạo hoàn chỉnh. Và trước khi ApplicationContext context = SpringApplication.run(Application.class, args);
8 bị phá hủy, thì cần gọi @Component
public class Car {
// Báo cho Spring tìm bean nào phù hợp với Engine interface
// Và có một bean phù hợp là ChinaEngine
// Nó tương đương với = new ChinaEngine()
@Autowired
private final Engine engine;
}
9 tương tự như trên.Dùng trong thực tế thì hai annotation trên làm các nhiệm vụ như: @Component
public class Car {
// Báo cho Spring tìm bean nào phù hợp với Engine interface
// Và có một bean phù hợp là ChinaEngine
// Nó tương đương với = new ChinaEngine()
@Autowired
private final Engine engine;
}
3 dùng để thực hiện một số task khi khởi tạo bean@Component
public class Car {
// Báo cho Spring tìm bean nào phù hợp với Engine interface
// Và có một bean phù hợp là ChinaEngine
// Nó tương đương với = new ChinaEngine()
@Autowired
private final Engine engine;
}
0 thực hiện các task để dọn dẹp bean sau khi dùng xong
2. Các loại beanNói đúng hơn thì gọi là các scope, phân loại dựa trên số lượng bean được tạo ra. Bean gồm có 5 scope: - Singleton (mặc định): IoC container chỉ tạo đúng duy nhất 1 object từ class bean này
- Prototype: return một bean object riêng biệt cho mỗi lần sử dụng.
- Request: tạo mỗi bean cho mỗi request
- Session: tạo mỗi bean cho mỗi session
- Global session: tạo mỗi bean cho mỗi global session (cái này không hiểu lắm)
Trong 5 scope trên chúng ta chỉ quan tâm tới hai scope đầu. Thường thì các bạn sẽ ít đụng tới prototype bean, nhưng mình cũng viết ra tại đây luôn. Đối với singleton bean thì khỏi cần đánh dấu gì hết, nó là mặc định rồi. Còn nếu muốn chỉ định một class là prototype bean thì dùng @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
2 như sau.ApplicationContext context = SpringApplication.run(Application.class, args);
2Nói rõ hơn về prototype bean, ví dụ bean X được sử dụng bởi hai bean khác là A, B: - Nếu X là singleton bean, thì chỉ có một object X được tạo ra. A và B dùng chung X.
- Nếu X là prototype bean, thì có 2 X được tạo ra cho 2 bean khác sử dụng là X cho A và X cho B.
3. Cách định nghĩa beanCó 3 cách định nghĩa class là một bean: - Khai báo trong file XML
- Dùng annotation trên class
- Dùng
@Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
3 và @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
4
Tùy từng trường hợp cụ thể mà dùng cho phù hợp. Ví dụ trong series này mình không bàn sâu về cấu hình bean bằng XML (do Spring Boot sinh ra không phải để cấu hình). 3.1. Dùng XML, annotationsNhưng đơn giản, các bạn cũng nên biết trước đây Spring dùng XML để cấu hình các bean như sau. Nó khá là cực nên người ta dùng cách khác hay hơn. ApplicationContext context = SpringApplication.run(Application.class, args);
3Do đó người ta mới dùng cách cấu hình bean dựa trên các annotation như // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
1. Cụ thể thì như bài trước có nói, chỉ cần đánh dấu // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
1 lên trên class thì IoC sẽ biết và tạo bean từ class đó.ApplicationContext context = SpringApplication.run(Application.class, args);
4Ngoài ra có các annotations khác cụ thể hơn như @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
7, @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
8, @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
9,… cũng bao gồm // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
1, nên tác dụng của chúng cũng là tạo bean.3.3. Dùng @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
4 bên trong @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
3Cách này dùng cho trường hợp bean cần thực hiện nhiều thao tác phức tạp để khởi tạo, hoặc có nhiều bean liên quan với nhau. Do đó, thay vì khởi tạo riêng rẽ từng class là từng bean, thì gom chung các bean cần khởi tạo lại bỏ vào class chứa là @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
3.Thường thì các class đánh dấu @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
3 có hậu tố là Config.ApplicationContext context = SpringApplication.run(Application.class, args);
5Khi Spring tìm thấy class @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
3, nó sẽ tạo bean của class này trước (do @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
3 cũng là // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
1). Trong khi tạo thì các logic khởi tạo cũng được thực thi, để chuẩn bị sẵn sàng tạo các @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
4 bên trong.Sau đó Spring Boot sẽ tìm các method được đánh dấu @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
4 bên trong @Component
public class Car {
private final Engine engine;
// Các bản Spring Boot mới thì không cần @Autowired trên constructor
public Car(Engine engine) {
this.engine = engine;
}
}
3 để tạo bean. Thường thì các bean dạng này ngắn và return ngay object chứ không phải để Spring Boot tạo ra.Các bean cũng được đưa vào ApplicationContext như bình thường. Tuy nhiên, không phải class nào đánh dấu cũng được tạo bean. Mà phải có điều kiện quá trình component scan của IoC phải tìm thấy nó. Chúng ta sẽ đi tiếp về component scan ngay sau đây. 4. Component scan4.1. Cách component scan hoạt độngKhi ứng dụng Spring Boot bắt đầu chạy, thì nó sẽ tìm hết các class đánh dấu là bean trong chương trình và tạo bean. Quá trình tìm kiếm các bean này gọi là component scan. Component scan sẽ tìm toàn bộ class ở package cùng cấp hoặc các package thấp hơn
Do đó, class đánh dấu @Component
public class VNEngine implements Engine {
@Override
public void run() {}
}
1 có chứa main method sẽ là nơi bắt đầu. Spring Boot sẽ tìm từ package này (package gốc) tìm xuống để tạo các bean.ApplicationContext context = SpringApplication.run(Application.class, args);
6Do cấu trúc thư mục mặc định của Spring Boot nó thế, nên từ package gốc có @Component
public class VNEngine implements Engine {
@Override
public void run() {}
}
2 là @Component
public class VNEngine implements Engine {
@Override
public void run() {}
}
3, nó sẽ tìm:- Các class cùng cấp, tìm được
@Component
public class VNEngine implements Engine {
@Override
public void run() {}
}
4 class, tạo bean - Tìm xuống các package thấp hơn như
@Component
public class VNEngine implements Engine {
@Override
public void run() {}
}
5 và @Component
public class VNEngine implements Engine {
@Override
public void run() {}
}
6, tìm thêm được các class như // Lấy ra bean có class cụ thể
Car car = context.getBean(Car.class);
// Lấy ra theo tên và class
// Tuy là Engine.class nhưng Engine lại là interface
Engine engine = context.getBean("ChinaEngine", Engine.class);
0, ApplicationContext context = SpringApplication.run(Application.class, args);
8, @Component
public class VNEngine implements Engine {
@Override
public void run() {}
}
9 (@Component
@Primary
public class VNEngine implements Engine {
...
}
0 là interface nhé).
Do đó, mặc định mọi class được khai báo là bean đều có thể được tìm được. 4.2. Tùy chỉnh package tìm kiếmTrong trường hợp bạn chỉ muốn Spring Boot tìm các bean trong một package cụ thể, ví dụ chỉ tìm trong thư mục @Component
@Primary
public class VNEngine implements Engine {
...
}
1 thì có 2 cách như sau.
Bean có tác dụng gì trong Spring?
Spring Bean là các object trong Spring Framework, được khởi tạo thông qua Spring Container. Bất kỳ class Java POJO nào cũng có thể là Spring Bean nếu nó được cấu hình và khởi tạo thông qua container bằng việc cung cấp các thông tin cấu hình (các file config .
Bean wiring là gì?
Bean wiring là gì? Wiring, hoặc là Bean wiring là trường hợp mà các bean được kết hợp lại trong Spring container. Khi wiring bean, Spring container cần biết những bean nào cần và làm thế nào để container sử dụng dependency injection nối tất cả chúng lại với nhau.
CDI Bean là gì?
CDI bean là bean được quản lý bởi CDI container (giống như các spring bean bị quản lý bởi spring container). Bean ở đây là các class Java mà chúng ta có thể lấy từ trong container. Để tạo 1 bean có rất nhiều cách như khai báo trong file config, sử dụng annotation…
Bean annotation là gì?
Annotation Spring @Bean cho biết rằng một method tạo ra một bean sẽ được quản lý bởi Spring container. Nó là một annotation ở method. Trong khi cấu hình Java (@Configuration), phương thức được thực thi và giá trị trả về của nó được đăng ký dưới dạng bean trong BeanFactory.
| 
